PythonBasic

Python程序的組成

程序由模塊組成

模塊由語句、函數(shù)、類、數(shù)據(jù)等組成

語句包含表達(dá)式

表達(dá)式建立并處理數(shù)據(jù)對象

Python運(yùn)行

1、python3 hello.py

2、（前提：文件內(nèi)加上#！ /usr/bin/python3）

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

Python的交互提示模式

退出：ctrl+d / exit

# 井號開頭，注釋

Python核心數(shù)據(jù)類型

數(shù)字（int；float；復(fù)數(shù)complex（real、image）；布爾類型）

字符串

列表等

整型數(shù)int

整型數(shù)是不帶小數(shù)部分的數(shù)字。包括自然數(shù)、0、負(fù)數(shù)

如：-5、10000、0等

進(jìn)制：

十進(jìn)制：10，20，

二進(jìn)制：0b開頭，后面跟0～1

0b111；0b101；0b1111

八進(jìn)制：0o開頭，后面跟0～7

0o177 #127

0o11 #9

十六進(jìn)制：0x開頭，后面給0～9，A～F，a～f

0x11 #17

0xFF #255

ox1234ABCD

進(jìn)制轉(zhuǎn)換：

十進(jìn)制（十進(jìn)一）

二進(jìn)制（二進(jìn)一）

八進(jìn)制（八進(jìn)一）

十六進(jìn)制（十六進(jìn)一）

二進(jìn)制轉(zhuǎn)八進(jìn)制：三個(gè)數(shù)為一組

0b 11 011 001

0o 3 31

二進(jìn)制轉(zhuǎn)十六進(jìn)制：四個(gè)數(shù)為一組

0b 1101 1001

0x d 9

hex(i) 將整數(shù)轉(zhuǎn)換為十六進(jìn)制字符串

oct(i)將整數(shù)轉(zhuǎn)換為八進(jìn)制字符串

bin(i)將整數(shù)轉(zhuǎn)換為二進(jìn)制字符串

浮點(diǎn)型數(shù)float

浮點(diǎn)型數(shù)是帶有小數(shù)部分的數(shù)字

表示形式：

小數(shù)形式：3.14、3.1、3.、0.14、.14

科學(xué)計(jì)數(shù)法：e/E（正負(fù)號）指數(shù)：6.18E-1=0.618

復(fù)數(shù)complex

分為兩部分：

實(shí)部（real）

虛部（image）虛部以j或J結(jié)尾

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

布爾類型數(shù)bool

用來表示真和假兩個(gè)狀態(tài)的類型

True 表示真、值為1（條件滿足或成立）

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

空值None

None是一個(gè)表示不存在的特殊對象

作用：用來占位、用來變量解除綁定

表達(dá)式和運(yùn)算符（也叫操作符）

表達(dá)式expressioin

有一個(gè)數(shù)字或數(shù)字和運(yùn)算符組成

作用：通常讓計(jì)算機(jī)是做一些事情并返回結(jié)果

例如：1 + 2

運(yùn)算符：

算術(shù)運(yùn)算符：+、-、*、/、//、%、**

除法：得到的是浮點(diǎn)數(shù)，不會丟失小數(shù)部分

1/3 = 0.3333333333333333

4/2 = 2.0

地板除：除到的結(jié)果去掉小數(shù)部分向下取整

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

冪運(yùn)算：

x ** y

4 ** 2 = 16

3.0 ** 4.0 = 27

5.6 ** 1.418 = 11.506165654866916

運(yùn)算符的優(yōu)先級

**

*///%

+-

括號分組子表達(dá)式

用()可以將表達(dá)式分組，()內(nèi)的表達(dá)式先進(jìn)行計(jì)算

混合類型自動升級

1 + 2.14 返回浮點(diǎn)數(shù)3.14

variable 變量

作用：變量是用來綁定數(shù)據(jù)對象的標(biāo)識符

方法：

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

2、不能使用python的關(guān)鍵字做變量名

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

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

python關(guān)鍵字：True, False, None, is, del, if, elif等

statement 賦值語句

語法：

變量名 = 表達(dá)式

變量名1 = 變量名2 = 表達(dá)式

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

作用：

用于創(chuàng)建變量并將變量綁定（或關(guān)聯(lián)）在一個(gè)對象上

說明：

1、當(dāng)變量不存在時(shí)，創(chuàng)建該變量同時(shí)綁定在這個(gè)對象上

2、當(dāng)變量存在時(shí)，改變次此量綁定的對象

3、一個(gè)變量只能綁定一個(gè)對象

4、兩個(gè)變量可以同時(shí)綁定同一個(gè)對象

示例：

a = 10 # 創(chuàng)建一個(gè)變量，和10綁定在一起

b = 20

c = a + b # 創(chuàng)建變量c，和10+20的結(jié)果綁定在一起

a1 = b2 = c1 = 100

關(guān)聯(lián)、綁定、引用的含義

在python中，變量沒有類型

關(guān)聯(lián)、綁定、引用都是指變量和一個(gè)對象的關(guān)聯(lián)關(guān)系

在交互模式下查看變量綁定關(guān)系：help('__main__')

自動化內(nèi)存管理

a = 10000

創(chuàng)建“10000”數(shù)據(jù)對象在內(nèi)存；a和10000相關(guān)聯(lián)（通過a找到10000）；

b = 20000

創(chuàng)建“20000”數(shù)據(jù)對象在內(nèi)存；a和10000相關(guān)聯(lián)（通過b找到20000）；

a = a + b

創(chuàng)建“30000”數(shù)據(jù)對象在內(nèi)存；a和30000相關(guān)聯(lián)（通過a找到30000）； 10000被銷毀

python的內(nèi)存管理和引用計(jì)數(shù)

每個(gè)對象都會記錄有幾個(gè)變量引用自身，當(dāng)引用的數(shù)量為0時(shí)，則對象被銷毀，此種自動化內(nèi)存管理方式叫做引用計(jì)數(shù)

序列賦值

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

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

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

x, y = 1, 2

變量的交換綁定

a, b = b, a

is / is not 運(yùn)算符

作用：判斷兩個(gè)對象是否綁定同一個(gè)對象，如果是同一個(gè)對象，返回True，否則False。is not相反。

語法：

a = b = 10000

s is b # True

a = 10000

b = 10000

a is b # False，因?yàn)閯?chuàng)建了新的對象，他們綁定的不是同一個(gè)對象

小整數(shù)對象池：Cpython中整數(shù)-5～256永遠(yuǎn)存在與小整數(shù)對象池中，不會釋放，會重復(fù)使用。

a = 5

b = 5

a is b # True，因?yàn)樵谛≌麛?shù)對象池中的對象

id() 函數(shù)

作用：返回一個(gè)對象在內(nèi)存中的地址

格式：id(對象)

del 語句

作用：用于刪除變量，同時(shí)刪除與對象的關(guān)聯(lián)關(guān)系。如果可能則釋放對象。

語法：del 變量名

python的內(nèi)存管理和引用計(jì)數(shù)

每個(gè)對象都會記錄有幾個(gè)變量引用自身，當(dāng)引用的數(shù)量為0時(shí)，則對象被銷毀，此種自動化內(nèi)存管理方式叫做引用計(jì)數(shù)(reference count)

復(fù)合賦值算數(shù)運(yùn)算符

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ùn)算符

<

<=

>

>=

==

!=

語法：

左表達(dá)式 < 右表達(dá)式

說明：

比較運(yùn)算符返回布爾類型的值

示例：

10 < 20 # True

1 + 10 > 2 + 8 # True

10 < 20 <= 30 # True

數(shù)值對象的構(gòu)造函數(shù)

float(obj)

用字符串或數(shù)字轉(zhuǎn)換為浮點(diǎn)數(shù)，如果不給出參數(shù)則返回0

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

用數(shù)字或字符串轉(zhuǎn)換為整數(shù)，如果不給出參數(shù)，則返回0

compx(r=0.0, i=0.0)

用數(shù)字或字符創(chuàng)建一個(gè)復(fù)數(shù)

bool(x)

用x創(chuàng)建一個(gè)布爾值(True/False)

返回假值的情況

None 空

False 假

0, 0.0, 0j

''

()

[]

{}

set()

函數(shù)調(diào)用

函數(shù)名(傳參列表)

說明：

函數(shù)調(diào)用是表達(dá)式，一定會返回一個(gè)對象的引用關(guān)系

內(nèi)建數(shù)值型函數(shù)

abs()取絕對值

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

round(x, -1)

pow(x, y) x ** y

help() 函數(shù)

作用：查看函數(shù)幫助文檔

用法：help(函數(shù)名)

statement 語句

語句是有一些表達(dá)式等組成，通過一條語句可以獨(dú)立執(zhí)行來完成一部分事情并形成結(jié)果

一天語句建議寫在一行內(nèi)

多條語句寫在一行內(nèi)需要用分號(;)分開

示例：

print("hello")

x = 100 + 200

print(x)

del x

換行：

顯式換行 \

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

示例：

i = 1 + 2 + 3 \

+ 4 + 5

i = (1 + 2 + 3

+ 4 + 5)

input() 基本輸入函數(shù)

作用：從標(biāo)準(zhǔn)輸入設(shè)置上讀取一個(gè)字符串（末尾的換行符會被刪除）

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

說明：返回輸入的字符串（僅python3）“提示字符串”可以為空

示例：

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

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

print(1+int(s)) 轉(zhuǎn)換整形

print() 基本輸出函數(shù)

作用：將以系列的值以字符串形式輸出到標(biāo)準(zhǔn)輸出設(shè)備上，默認(rèn)是終端

格式：print(要打印的數(shù)據(jù))；各數(shù)據(jù)可以用逗號分隔開

示例：

print(1+2)

print("hello")

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

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

if 語句

作用：讓程序根據(jù)條件選擇的執(zhí)行某條語句或某些語句

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

語法：

if 真表達(dá)式1:

語句塊

elif 真表達(dá)式2:

語句塊2

elif 真表達(dá)式3:

語句塊3

……

else:

語句塊4

elif可以有多個(gè)；else只能有0個(gè)或1個(gè)；

要求：if語句內(nèi)部的語句通常要以4個(gè)空格的是縮進(jìn)來表示包含關(guān)系，相同的縮進(jìn)格式代表相同的所屬級別

s = input("請?jiān)佥斎胱址?")

j = int(s)

if j > 100:

print("Bigger than 100")

elif 0 < j < 20:

print("Between 0 and 20")

else:

print("Other")

if 語句的真值表達(dá)式

if 100:

print("真值")

# 等同于

if bool(100):

print("真值")

if 語句嵌套

if語句本身是由多條字句組成的一條復(fù)合語句

if語句可以作為語句嵌套到另一個(gè)語句的內(nèi)部

if 1 <= month <= 12:

print("是合法的月份")

if month <= 3:

print("是春季")

elif....

else:....

條件表達(dá)式

作用：如果真值表達(dá)式的布爾環(huán)境值為True，則執(zhí)行表達(dá)式1并返回結(jié)果的引用，否則執(zhí)行表達(dá)式2并返回結(jié)果的引用

語法：表達(dá)式1 if 真值表達(dá)式 else 表達(dá)式2

示例：

商場促銷滿100減20

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

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

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

pass 語句

作用：通常來填充語法空白，又名空語句

語法：psss

示例：

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

if 0 <= g <= 100:

psss

else:print("不處于成績范圍")

布爾運(yùn)算

運(yùn)算符：

not and or

布爾非操作：not

語法：not x

作用：對x進(jìn)行布爾取值，如bool(x)，為True，返回False，否則返回True

示例：

not True = False

not 100 = False

布爾與操作：and

語法：x and y

作用：優(yōu)先返回假值對象，當(dāng)bool(x)的為False時(shí)，返回x，否則返回y

示例：

True and True = True

True and False = False

100 and 200 = 200

布爾或操作：or

語法：x or y

作用：優(yōu)先返回真值對象，當(dāng)x為True時(shí)返回x，否則返回y

100 or 200 = 100 （都為真優(yōu)先返回左側(cè)的）

應(yīng)用：

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

if score < 0 or score > 100:

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

else:

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

正負(fù)號運(yùn)算符

+（正號） -（負(fù)號）

語法：

+ 表達(dá)式

- 表達(dá)式

示例：

a = 5

b = -a

str 字符串

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

表示方法：

' 單引號

" 雙引號

單引號和雙引號的區(qū)別：

單引號內(nèi)的雙引號不算結(jié)束符

雙引號內(nèi)的單引號不算結(jié)束符

''' 三單引號

""" 三雙引號

三引號字符串：

三引號字符串換行會自動轉(zhuǎn)換為換行符'\n'

三引號內(nèi)可以包含單引號和雙引號

s = '''Welcome to Beijing

I like Python!

I am learning!'''

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

用轉(zhuǎn)義序列代表特殊字符

字符串字面值中，用字符反斜杠后跟一些字符代表一個(gè)字符

字符串中的轉(zhuǎn)義字符表

\' \" \\

\n \r(光標(biāo)返回行首并替換) \f(換頁) \t(水平制表符) \v(垂直制表符)

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

\0oo(oo為兩位八進(jìn)制表示的字符)

\xXX(XX為兩位十六進(jìn)制表示的字符)

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

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

ASCII編碼

man ascii (八進(jìn)制十六進(jìn)制都可以表示)

常用ASCII：

字符 十進(jìn)制 十六進(jìn)制

'0' 48 0x30

'A' 65 0x41

'a' 97 0x61

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

chr(i) 返回i這個(gè)值所對應(yīng)的字符

print(ord('A')) # 65

print(ord('中'))# 20013

raw 字符串（原始字符串）

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

作用：讓轉(zhuǎn)義字符\無效

示例：

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

print(a)

print(len(a))

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

print(a)

print(len(a))

字符串的運(yùn)算

算術(shù)運(yùn)算符：

+ += * *=

+ 加號運(yùn)算符用于字符串的拼接

x = 'abcd' + 'efg'

print(x) # abcdefg

x += '123' # abcdefg123

* 運(yùn)算符用于生成重復(fù)的字符串

x = '123'

y = x * 2 # y = '123123'

比較運(yùn)算符：

> >= < <= == !=

示例：

'A' < 'B' # True

'B' < 'a' # True

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

'ABC' == 'abc' # False

in / not in

作用：用于序列、字典、集合，判斷某個(gè)值是否在該容器中返回TF

格式：對象 in 容器

示例：

s = 'Welcome to Ningbo!'

'to' in s #True

index 字符串的索引操作

python字符串str是不可以改變的字符序列

index 索引

索引語法：字符串[整數(shù)表達(dá)式]

說明：

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

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

python序列的反向索引是從-1開始的，-1代表最后一個(gè)，-2代表倒數(shù)第二個(gè)，第一個(gè)是-len(s)

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

最后一個(gè)s[len(s) - 1] = s[-1]

slice 切片

作用：從字符串序列中取出一部分相應(yīng)的元素重新組成一個(gè)字符串

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

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

說明：

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

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

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

1）沒用步長，相當(dāng)于取值完成后向后移動一個(gè)索引的位置（步長為1）

2）當(dāng)步長為正整數(shù)時(shí)，取正向切片：

補(bǔ)償默認(rèn)值為1，開始索引默認(rèn)值為0，結(jié)束索引的默認(rèn)值為len(s)

[開始：結(jié)束：步長]

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

反向：[::-1]

3）當(dāng)步長為負(fù)整數(shù)時(shí)，取反向切片：

反向切片時(shí)，默認(rèn)的起始位置為最后一個(gè)元素，默認(rèn)中止為第一個(gè)元素的前一個(gè)位置

示例：

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'

常用的序列函數(shù)

len(seq) 返回序列長度

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

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

示例：

s = 'ABCDE'

len(s)5

整數(shù)轉(zhuǎn)換為字符串函數(shù)

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

chr(i)返回i這個(gè)值所對應(yīng)的字符 = %c % i

hex(i) 將整數(shù)轉(zhuǎn)換為十六進(jìn)制字符串

oct(i)將整數(shù)轉(zhuǎn)換為八進(jìn)制字符串

bin(i)將整數(shù)轉(zhuǎn)換為二進(jìn)制字符串

str() 字符串的構(gòu)造、創(chuàng)建函數(shù)

str(obj='')將對象轉(zhuǎn)換為字符串

常見的字符串方法

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

注：方法的調(diào)用屬于表達(dá)式，通常可以返回一個(gè)值或None

示例：

'abc'.isalpha()

if 'abc'.isalpha():

print("True")

s.(30, '#') #給出寬度居中 默認(rèn)為空格

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

s.find()

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

s.upper() #返回大寫

s.lower() #返回小寫

s.replace(old, new, 個(gè)數(shù))

s.startwith() #判斷開頭

s.endswith() #判斷結(jié)尾

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

字符串格式化表達(dá)式

運(yùn)算符：%

作用：生成一定格式的字符串

語法：

格式字符串 % 參數(shù)值

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

格式字符串中的%為占位符

示例：

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

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

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

s = fmt % (name, age)

print(s)

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

占位符意義

%s 字符串用str轉(zhuǎn)換

%r 字符串用repr轉(zhuǎn)換

%c 整數(shù)轉(zhuǎn)換為單個(gè)字符

%d 十進(jìn)制整數(shù)

%o 八進(jìn)制整數(shù)

%x 十六進(jìn)制整數(shù)（a-f小寫）

%X 十六進(jìn)制整數(shù)（a-f大寫）

%e 指數(shù)型浮點(diǎn)數(shù)（e小寫）

%E 指數(shù)型浮點(diǎn)數(shù)（E大寫）

%f 浮點(diǎn)十進(jìn)制

%g 自動轉(zhuǎn)換指數(shù)

%% %

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

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

- 左對齊

+ 顯示正號

0 補(bǔ)零

寬度（整數(shù)）

寬度.精度(整數(shù))

例如：

'%10d' % 123 # ' 123'

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

'%010d'% 123 # '0000000000123'

'%7.3f' % 3.1415926

format 函數(shù)格式化字符串

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

print(s)

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

s2 = "haha {0}"

s2.format("shibushi")

while 循環(huán)語句

作用：根據(jù)一定條件，重復(fù)的執(zhí)行一條語句或多條語句

語法：

while 真表達(dá)式:

語句

else:

語句

1、先執(zhí)行真值表達(dá)式，判斷True/False

2、如果為True則執(zhí)行語句快1，然后跳轉(zhuǎn)到第一步

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

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

注意事項(xiàng)：

1、要控制真值表達(dá)式來防止死循環(huán)

2、通常用真值表達(dá)式內(nèi)的變量來控制循環(huán)條件

3、通常要在循環(huán)語句快內(nèi)改變循環(huán)變量來控制熏昏的次數(shù)和變量的走向

示例1：

i = 1

while i < 5:

print("Hello World!")

i += 1

else:

print("條件不足，此時(shí)變量i=%d，循環(huán)結(jié)束" % i)

示例2: 只用一個(gè)變量

while 1 <= n:

print("Hello World!")

n -= 1

else:

print("條件不足，此時(shí)變量n=%d，循環(huán)結(jié)束" % n)

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

i = 1

while i <= 20:

print(i)

i += 1

print("End!")

while 語句嵌套

while語句本身是語句，和其他語句一樣，可以放在其他符合語句的內(nèi)部

語法：

while 真值表達(dá)式:

……

while 真值表達(dá)式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語句中止當(dāng)前循環(huán)的語句，常常和if連用

說明：

1、當(dāng)break語句執(zhí)行后，此循環(huán)語句break之后的語句將不再執(zhí)行

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

3、break語句中止循環(huán)時(shí)，循環(huán)語句的else子句的語句將不會執(zhí)行

4、break語句只能終止當(dāng)前循環(huán)語句的執(zhí)行，如果有循環(huán)嵌套時(shí)，不會跳出嵌套的外重循環(huán)

5、break語句只能在循環(huán)語句中（while或for）內(nèi)部使用

示例：

i = 1

while i <= 6:

print("本次循環(huán)開始時(shí)：", i)

if i ==3:

break

print("本次循環(huán)結(jié)束時(shí)：", i)

i += 1

死循環(huán)

概念：死循環(huán)是指循環(huán)條件一直成立的循環(huán)、通常用break語句來中止循環(huán)，死循環(huán)的else子句永遠(yuǎn)不會執(zhí)行

示例：

while True:

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

if n == 0:

break

print(n)

for 語句

作用：用來遍歷可迭代對象的數(shù)據(jù)元素，可迭代對象是指能以此獲取數(shù)據(jù)元素的對象，可迭代對象包括：

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

語法：

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

語句快1

else: (結(jié)束循環(huán)后)

語句快2

說明：

1、可迭代對象每次提供一個(gè)元素依次賦值給變量列表中的變量，賦值完畢后執(zhí)行語句塊1，重復(fù)執(zhí)行此步驟，直到可迭代對象不能提供數(shù)據(jù)為止。

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

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

4、當(dāng)在循環(huán)內(nèi)部使用break中止循環(huán)時(shí)，else子句部分語句不會執(zhí)行。

示例：

s = 'ABCDE'

for ch in s:

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

else:

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

print("程序退出")

for 語句嵌套

for 語句內(nèi)部可以放冉義語句，包含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() 函數(shù)

格式見：help(range)

作用：用來創(chuàng)建一個(gè)生成一系列整數(shù)的迭代對象（也叫做整數(shù)序列生成器）

函數(shù)：

range(stop)從零開始，每次生成一個(gè)整數(shù)后加1操作，直到stop為止（不包含stop）

rang(start, stop[, step])

從start開始，每次生成一個(gè)整數(shù)后移動step，直到stop為止（不包含stop，且step可以是負(fù)數(shù)）

說明：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 語句

作用：用于循環(huán)語句（while、for）中，不再執(zhí)行本次循環(huán)內(nèi)continue之后的語句，重新開始一次新的循環(huán)

說明：

1、在while語句中，執(zhí)行continue語句將會直接跳轉(zhuǎn)到while語句的真值表達(dá)式處重新判斷循環(huán)條件

2、在for語句中，執(zhí)行continue語句，將會從可迭代對象中取下一個(gè)元素，綁定變量后再次進(jìn)行循環(huán)

示例：

for x in range(5):

if x == 2:

continue

print(x)

sequence 序列類型

字符串 str

列表 list

元組 tuple

字節(jié)串 bytes

字節(jié)數(shù)組 bytearray

list 列表

概念：列表式由一系列特定元素組成的，元素和元素之間沒有任何關(guān)聯(lián)關(guān)系，但他們之間有先后順序關(guān)系。列表式一種容器，是序列的一種，是可以被改變的序列

創(chuàng)建列表：

L = [] # 空列表

L = [1, 2, 3, 4]

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

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

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

構(gòu)造函數(shù)：list()、list(interable) 用可迭代對象創(chuàng)建一個(gè)列表

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

L = list("ABCD")

list 運(yùn)算

算術(shù)運(yùn)算：

+ += * *=

+ 用于拼接

x = [1, 2, 3]

y = [4, 5, 6]

z = x + y (拼接)

+= 用于愿列表與右側(cè)的可迭代對象進(jìn)行拼接，生成新的列表

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

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

* 用于生成重復(fù)的列表

x = [1, 2]

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

比較運(yùn)算：

< <= > >= == !=

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

作用：判斷一個(gè)數(shù)據(jù)元素是否怒在容器（列表內(nèi)），如果存在，返回True，否則返回False

示例：

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

1 in x # True

2 in x # True

'四' not in x # False

list index / slice

取值語法：列表[整數(shù)表達(dá)式]

取值用法：列表的索引取值與字符串的索引取值規(guī)則完全相同，列表的索引為分正向索引和反向索引

x = list(range(9))

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

索引賦值：列表式可變的序列，可以通過索引賦值改變列表中地元素

索引語法：列表[索引] = 表達(dá)式

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

說明：切片賦值的賦值運(yùn)算符的右側(cè)必須是一個(gè)可迭代對象

切出來然后再賦值

示例：

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)

注意事項(xiàng)：對于步長不等于1的切片賦值，賦值運(yùn)算符的右側(cè)的可迭代對象提供元素的個(gè)數(shù)一定要等于切片切出的段數(shù)

L += 'ABC' 會改變原有id，相當(dāng)于新建變量

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]

常用的序列函數(shù)

len(x)返回序列的長度

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

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

sum(x)返回序列中所有元素的和（必須是數(shù)值類型）

any(x) 真值測試，如果列表中其中有一個(gè)值為真

all(x) 真值測試，如果所有都為真值

list 常用方法

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

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

L.count(x) 返回列表中x的個(gè)數(shù)

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

L.copy() 復(fù)制列表

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

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

L.clear() 清空

L.sort(reverse=False) 按元素進(jìn)行排序，默認(rèn)為從小到大升序

L.reverse() 反轉(zhuǎn)順序

L.pop([index]) 刪除元素，默認(rèn)最后一個(gè)，會返回值

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

S.split(sep=None)

使用sep作為分隔符分隔s字符串，返回分割后的字符串列表，默認(rèn)為空白字符作文分隔符

S.join(interable)

使用可迭代對象的字符串，返回一個(gè)中間用S進(jìn)行分割的字符串

示例

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

淺拷貝：是指在復(fù)制過程只復(fù)制一層變量，不會復(fù)制深層變量綁定的對象的復(fù)制過程

深拷貝：深拷貝通常只對可變對象進(jìn)行解釋不可變對象通常不變

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 列表推導(dǎo)式

列表推導(dǎo)式是用可迭代對象依次生成帶有多個(gè)元素的列表的表達(dá)式

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

語法：

[表達(dá)式 for 變量 in 可迭代對象]

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

示例：

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

L = [i for i in range(1,100,2)] #打印出1-100以內(nèi)的奇數(shù)

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

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

嵌套：

[表達(dá)式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一樣元組可以存放任意類型的元素，一單元組生成，則他不可以改變

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

t = ()

t = 200,

t = (20,)

t = (1, 2, 3)

t = 100, 200, 300

構(gòu)造函數(shù) tuple

tuple()生成一個(gè)空的元組，等同于()

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

示例：

t = tuple()

t = tuple(range(10))

t = tuple('hello')

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

元組的算術(shù)運(yùn)算：

+ += * *= 用法語列表的用法完全相同

元組的比較運(yùn)算：

< <= > >= == != 和列表用法完全相同

in / not in 切片、索引規(guī)則與列表完全相同

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

元祖的方法：help(tuple)

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

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

可以用于序列的函數(shù)

len, max, min, sum, all, any

構(gòu)造函數(shù):

str(obj)

list(interable)

tuple(interable)

其他函數(shù)：

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

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

返回已排序的列表

示例：

for x in reversed('ABCD')；

print(x)

L = [8,]

dict 字典

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

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

3、字典的數(shù)據(jù)沒有先后順序關(guān)系，字典的存儲是無序的

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

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

字典的字面值表示方式：

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

創(chuàng)建字典

d = {}

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

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

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

字典的構(gòu)造函數(shù)

dict() 傳建一個(gè)空字典，等同于{}

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

dict(**kargs) 關(guān)鍵字傳參形式生成一個(gè)字典

示例：

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（字節(jié)數(shù)組）

字典的鍵索引

用[]運(yùn)算符可以獲取字典內(nèi)'鍵'所對應(yīng)的'值'

語法：字典[鍵]

獲取數(shù)據(jù)元素

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

print(d['age'])

添加、修改字典元素

字典[鍵] = 表達(dá)式

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運(yùn)算符來判斷一個(gè)‘鍵’是否存在于字典中，如果存在則返回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 迭代訪問

字典是可迭代對象，字典只能對鍵進(jìn)行迭代訪問

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

for x in d:

print(x)

print(d[x])

dict 方法

D.clear()清空字典

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

D.copy()返回字典D的副本,只復(fù)制一層(淺拷貝)

D.update(D2)將字典 D2 合并到D中，如果鍵相同，則此鍵的值取D2的值作為新值

D.get(key, default)返回鍵key所對應(yīng)的值,如果沒有此鍵，則返回default

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

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

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

示例：

for k, v in d.items():

print(k, v)

dict 推導(dǎo)式

字典推導(dǎo)式是用可迭代對象依次生成字典內(nèi)元素的表達(dá)式

語法：

{鍵表達(dá)式 : 真值表達(dá)式 for 變量 in 可迭代對象 [if 真值表達(dá)式]}

注：[]的內(nèi)容可以省略

示例：

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

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

set 集合

集合是可變的容器

集合內(nèi)的數(shù)據(jù)對象是唯一的（不能重復(fù)多次的）

集合是無序的儲存結(jié)構(gòu)，集合中的數(shù)據(jù)沒有先后關(guān)系

集合內(nèi)的元素必須是不可變對象

集合是可迭代的

集合是相當(dāng)于只有鍵沒有值的字典（鍵則是集合的數(shù)據(jù)）

創(chuàng)建集合

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

集合的運(yùn)算：

交集，并集，補(bǔ)集，子集，超集

& 交集：

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

- 生成兩個(gè)集合的補(bǔ)集：生成屬于s1，但不屬于s2的所有元素集合

s1 = {1,2,3}

s2 = {2,3,4}

s3 = s1 - s2 # s3 = {1}

^ 生成兩個(gè)集合的對稱補(bǔ)集：

s1 = {1,2,3}

s2 = {2,3,4}

s3 = s1 ^ s2 # s3 = {1,4}相當(dāng)于 s3 = (s1-s2) | (s2-s1)

< 判斷一個(gè)集合是另一個(gè)集合的子集

> 判斷一個(gè)集合是另一個(gè)集合的超集

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 集合的數(shù)據(jù)沒有先后順序

in / not in

等同于字典，in運(yùn)算符用于集合中，當(dāng)某個(gè)值存在于集合中，則為真，否則為假

not in 與 in 返回值相反

示例：

s = {1, 'Two', 3.14}

1 in s # True

3.14 not in s # False

可用于集合的函數(shù)：

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)在集合中添加一個(gè)新的元素e；如果元素已經(jīng)存在，則不添加

S.remove(e)從集合中刪除一個(gè)元素，如果元素不存在于集合中，則會產(chǎn)生一個(gè)KeyError錯(cuò)誤

S.discard(e)從集合S中移除一個(gè)元素e,在元素e不存在時(shí)什么都不做;

S.clear()清空集合內(nèi)的所有元素

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

S.pop()從集合S中刪除一個(gè)隨機(jī)元素;如果此集合為空，則引發(fā)KeyError異常

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

S.difference(s2)用S - s2 運(yùn)算，返回存在于在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)返回對稱補(bǔ)集,等同于 S ^ s2

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

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

set 集合推導(dǎo)式

用可迭代對象來創(chuàng)建（生成）集合的表達(dá)式

語法：

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

[]部分可以省略

示例：

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

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

集合推導(dǎo)式的嵌套規(guī)則和列表推導(dǎo)式相同

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

frozensey 固定集合

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

作用：

固定集合可以作為字典的鍵，也可以作為集合的值（元素）

創(chuàng)建固定集合：

fs = frozenset()

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

frozenset(interable)

固定集合的運(yùn)算等同于集合運(yùn)算

總結(jié)

不可變數(shù)據(jù)類型：

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

可變數(shù)據(jù)類型：

list, dict, set, bytearray(字節(jié)數(shù)組)

運(yùn)算符：

+ - * / // % **

> >= < <= == !=

is is not

in not in

not and or

& | ^

表達(dá)式：

1

1 + 2

len([1,2,3])

條件表達(dá)式： x if x > y else y

全部的推導(dǎo)式：

列表、字典、集合推導(dǎo)式（三種）

語句：

表達(dá)式語句：

print("ABC")

'hello'

賦值語句：

a = 100

a = b = c = 200

x, y = 100, 200

if 語句

while 語句

for 語句

break 語句

continue 語句

pass 語句

del 語句

內(nèi)建函數(shù)：

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

創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎勵(lì)來咯，堅(jiān)持創(chuàng)作打卡瓜分現(xiàn)金大獎

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。