python偏移量

① 【技術貼】python數據類型之列表

列表是由一系列按特定順序排列的元素組成的。在Python中，用[]來表示列表，並用逗號來分隔其中的元素。

我們可以創建包含字母，數字或者任何東西的列表。其中列表中的元素之間可以沒有任何的關系。由於列表通常包含多個元素，再給創建的列表命名時，一般使用復數的名稱，如names.

names = ["kitty","anne","jerry"]

print(names)

輸出的結果為方括弧[] 引號 '' 元素

['kitty', 'anne', 'jerry']

注意：列表的偏移量是從0開始的，而不是我們習慣的 1 開始

teacher=['七七','卡西','延君']

teacher[0]='七七'

teacher[1]='卡西'

teacher[2]='延君談襪鉛'

口訣：「左右空，取到頭；左要取，右不取」

teacher=['七七','卡西','延君']

teacher[：2]=['七七','卡西']

格式：列表.append('元素名')

teacher=['七七','卡西','延君']

teacher.append('琦玉')  

# 結果為 teacher=['七七','卡西','延君'，'琦玉']

list.extend([元素1，元素2])：在list列表末端增加多個元素；

list.insert(元素序號，元素)：在list列表任意位置增加一個元素

 

teacher=['七七','卡西','延君','琦玉']

del teacher[3]

# 結果為 teacher=['七七','卡西','延君']

>>> str=[0,1,2,3,4,5,6]

>>> del str[2:4] #刪除從第2個元素開始，到第4個為止的元素(但是不包括尾部元素)

>>> str

[0, 1, 4, 5, 6]

>>> str=[0,1,2,3,4,5,6]

>>> del str

>>> str #刪除後，找不到對象

Traceback (most recent call last):File "<pyshell#27>", line 1, in <mole>strNameError: name 'str' is not defined

注意：del是刪除引用(變數)而不是刪除對象(數好虛據)，對象由自動垃圾回收機制（GC）刪除。

 

1，a = list.count(元素)：計算它的參數在列表中出現的次數，並將次數返回；

2，a = list.index(元素)：返回它的參數在列表中的位置，返回元素序號；#若有多個元素相同，此為只返回首端起第一個。

3，a = list.index(元素， 序號1，序號2)：在序號1和序號2范圍內，返回列表中元素位置。 #若有多個元素相同，此為只返回首端起第一個。

4，list.reverse() == list[::-1]：將整個列表內元素反過含好來排列：[1, 2, 3, 4].reverse() == [4, 3, 2, 1]；

5，list.sort()：將所有元素，從小到大排列；

6.sorted方法

sorted返回一個有序的副本，並且類型總是列表，如下：

② python之time模塊

time 模塊常用的信正握與時間相關的類和函數:

time 模塊的 struct_time 類代表一個時間對象，可以通過 索引和屬性名 訪問值。 對應關系如下：

索引 —— 屬性 值
0 —— tm_year（年） 如：1945
1 —— tm_mon（月） 1 ~ 12
2 —— tm_mday（日） 1 ~ 31
3 —— tm_hour（時） 0 ~ 23
4 —— tm_min（分） 0 ~ 59
5 —— tm_sec（秒） 0 ~ 61
6 —— tm_wday（周） 0 ~ 6
7 —— tm_yday（一年內第幾天） 1 ~ 366
8 —— tm_isdst（夏時令） -1、0、1

localtime() 表示當前時間，返回類型為 struct_time 對象 ，示例如下所示：

輸出結果：

time()——返回當前時間的時間戳
gmtime([secs])——將時間戳轉換為格林威治天文時間下的 struct_time，可選參數 secs 表示從 epoch 到現在的秒數，默認為當前時間
localtime([secs])——與 gmtime() 相似，返回當地時間下的 struct_time
mktime(t) localtime() 的反函數
asctime([t]) 接收一個 struct_time 表示的時間，返回形式為：Mon Dec 2 08:53:47 2019 的字元串
ctime([secs]) ctime(secs) 相當於 asctime(localtime(secs))
strftime(format[, t]) 格式化日期，接收一個 struct_time 表示的時間，並返回以可讀字元串表示的當地時間
sleep(secs) 暫停執行調用線程指定的秒數
altzone 本地 DST 時區的偏移量，以 UTC 為單位的秒數
timezone 本地（非 DST）時區的偏移量，UTC 以西的秒數清答（西歐大部分地區為負，美國為正，英國為零）
tzname 兩個字元串的元組：第一個是本地非 DST 時區的名滑慶稱，第二個是本地 DST 時區的名稱

基本使用如下所示：

strftime 函數日期格式化符號說明如下所示：

③ python列名稱有中文括弧怎麼讀取

一、萌新語法
輸入和輸出
print()

#列印括弧的內容

#第一種：不帶引號，讓計算機讀懂括弧里的內容，列印最終的結果

>>>print(1+1)

#第二種：帶單引號，計算機無須理解，原樣復述引號中的內容

>>>print('秋水共長天一色')

秋水共長天一色

#第三種：帶雙引號，作用和單引號一樣；當列印內容中有單引號時，可以使用雙引號

>>>print("Let's go")

Let's go

>>> print('Let's go')

Let's go

#也可以使用轉義字元+單引號(')來實現單引號

#第四種：帶三引號，實現換行

>>>print('''python小課

最好的python課程''')
pyton小課

最好的python課程

# 採用轉義字元"n"也可以換行

input()

#收集信息

>>>name = input('請輸入你的forchange ID：')

# 使用變數賦值來獲取輸入的信息

變數的命名
1.只能是一個詞；

2.只能包含字母、數字鬧飢和下劃線；

3.不能以數字開頭；

4.盡量描述包含的數據內容；

5.不要使用python函數名和關鍵字。

>>>number = 34

>>>name = 'forchange'

>>>list_class = ['基礎語法課程'，'爬蟲分析初階'，'爬蟲分析進階'，'自動化辦公']

#以上number，name，list_class都是是變數名

條件判斷
條件判斷的解釋：讓計算機知道，在什麼條件下，該去做什麼。

單向判斷
if…

#如果條件成立，就執行語句

>>>number = 6

>>>if number > 3:

... pirnt(number)

6

#注意格式！if後面要加冒號，同時執行語句要縮進四個空格。(空格和tab，我選空格?^^)

雙向判斷
if…else…

#條件成立執行if語句，否則執行else語句

number = 7

if number < 3:

pirnt(number)

else:

number = number - 3

print(number)

#結果輸出為4

#if和else是同一層級，不需要縮進。if和else下的執行語句都需要縮進四個空格。

if…else…和if…if…的區別

#if…else…一個條件滿足後就不會進行其他判斷（if代表的條件和else代表的條件是互斥的）

#if…if…會遍歷所有條件，一個條件無論滿足還是不滿足，都會進行下一個條件的判斷

多向判斷
if…elif…else

#三個及其以上條件的判斷

grade = 65

if 80 <= grade <=100:

print('成績優秀')

elif 60 <= grade < 80:

print('成績中等')

else :

print('成績差')

#結果輸出為成績中等

IF嵌套
if 嵌套

#使用if進行條件判斷，還希望在條件成立的執行語句中再增加條件判斷，即if中還有if，這兩個if非平級

grade = 15

if 80 <= grade <=100:

print('成績優秀')

elif 60 <= grade < 80:

print('成績中等')

else :

print('成績差')

if 20<= grade <60:

print('再努力一把，還有救！')

else :

print('你要比以前更努力才行，你可以的！')

#結果輸出為：

成績差

你要比以前更努力才行，你可以的！

#注意，嵌套的第二個if縮進了4個空格，表示不同的層級。

二、數據類型
數據類型
python常見的數據類型：字元串，整數型，浮點數，列表，字典，布爾值，元組。

最基本的數據類型有三種：

字元串str：用引號括起來的文本（如：'python'、'123'、'風變編程'）

整數int：不帶小數點的數字（如：-1、1、0、520、1314）

浮點數float：帶小數點的數字，運算結果存在誤差（如：-0.15、3.1415、1.0)

以下的數據結構會有一節或兩節的課程介紹，可輕松上手。

列表list：是一種悶畢有序的集合，可以隨時增加或刪除其中的元素。標識是中括弧[]。

元組tuple：一種類似列表的數據類型，但是不能被修改。

字典dice：全稱為dictionary，使用鍵值對（螞彎芹key-value）作為存儲方式。標識是大括弧{}。

布爾值bool：表示真假的數據類型，只有兩個值，True和False。

數據的操作
字元串的拼接
初階用法：使用 ' + ' 進行字元串的拼接

>>>print('風變'+'編程')

風變編程

>>>name = '醬醬'

>>>begin = '我叫'

>>>print(begin + name)

我叫醬醬

進階用法：使用 ' % ' 進行字元串的拼接

>>>name = '《鳳求凰》'

>>>number = 1

>>>print('司馬相如以%d曲%s打動了卓文君' %(number,name))

司馬相如以1曲《鳳求凰》打動了卓文君

四則運算
運算符 表示 例子
+ 加 1 + 1 輸出結果為2
- 減 1 - 1 輸出結果為0
* 乘 3 * 2 輸出結果為6
/ 除 2 / 1 輸出結果為2
% 取模-返回除法的余數 5 % 2 輸出結果為1
** 冪-返回x的y次冪 2 ** 3 輸出結果為8
// 取整除-返回商的整數部分 11 // 2 輸出結果為5
運算優先順序：

與平時運算優先順序一樣：從左到右順著來，括弧里的優先算，乘除排在加減前。

數據轉換
type()

#查看變數的數據類型

>>>who = 'xiaojiangjiang'

>>>print(type(who))

<class 'str'>

#結果顯示這是一個字元串類型的數據

str()

#將其他數據類型強制轉換為字元串

>>>begin = '我吃了'

>>>number = 1

>>>fruit = '個水果'

>>>print(begin + str(number) +fruit)

我吃了1個水果

#進行字元串拼接時，不同數據類型不能直接使用'+'連接，需要現將整數轉化為字元串類型

int()

#將整數形式的字元串轉化為整數（文本類字元串和浮點形式的字元串不能轉化為整數）

#對浮點數直接抹零取整

>>>print(int(3.8))

3

float()

#將整數和字元串轉換為浮點數(文字類字元串無法轉換）

>>>print(float(8))

8.0

list()

#將數據轉換為列表類型

>>>a = 'python小課'

>>>print(list(a))

['p', 'y', 't', 'h', 'o', 'n', '小', '課']

len()

#用於檢查某個數據的長度

>>>bros = ['劉備','關羽','張飛']

>>>print(len(bros))

3

>>>emotion = 'happy'

>>>print(len(emotion))

5

數據的常用語法
列表語法
列表的操作可分為兩種類型，一種類型為對列表元素的處理，另一種類型為對列表的處理，每種類型都有四種操作：提取，修改，增加，刪除（取改增刪）。

偏移量：對列表元素的位置編號。

#列表的偏移量從0開始計算

#如果要提取一段列表，需要使用切片的形式[a:b]：從a到b的元素，但不包括b（a <= X < b）；冒號某側如果沒有數字，則全取

>>>list = ['松','竹','梅']

>>>print(list[0])

>>>print(list[1:2])

>>>print(list[:2])

松

['竹']

['松','竹']

#松，竹，梅三者的偏移量分辨是0，1，2。

列表元素的提取

>>>list = ['松','竹','梅']

>>>print(list[0])

松

>>>list = [['松','松樹'],['竹','竹子'],['梅','梅花']]

>>>print(list[0][1])

松樹

#嵌套列表的提取

列表元素的修改

>>>list = ['松','竹','梅']

>>>list[0] = '松樹'

>>>print(list)

['松樹', '竹', '梅']

列表元素的增加

append()

#是列表的方法，在括弧內添加一個元素，可以將該元素添加到列表末尾

>>>list = ['松','竹']

>>>list.append('梅')

>>>print(list)

['松','竹','梅']

易錯一：用append時不能對列表賦值

>>>list = ['松','竹']

>>>list = list.append('梅')

>>>print(list)

None

#第二行語法錯誤

易錯二：append後面是小括弧，而非中括弧

>>>list = ['松','竹']

>>>list.append['梅']

>>>print(list)

TypeError: 'builtin_function_or_method' object is not subscriptable

#第二行語法錯誤

易錯三：append不能一次添加多個元素

>>>list = ['松','竹']

>>>list.append('梅','歲寒三友')

>>>print(list)

TypeError: append() takes exactly one argument (2 given)

#第二行語法錯誤

列表元素的刪除

del

#刪除命令

易錯一：每次只能刪除一個元素，

易錯二：刪除多個元素時，要重新計算偏移量

>>>list = ['松','竹','梅']

>>>del list[0]

>>>print(list)

>>>del list[0]

>>>print(list)

['竹', '梅']

['梅']

列表的切片（即列表層面的提取，一次提取若干個元素）

>>>list = ['松','竹','梅']

>>>print(list[1:2])

>>>print(list[:2])

['竹']

['松','竹']

#注意:列表的切片提取出來的是列表

列表的修改

#同樣是使用賦值語句，注意是對列表的賦值

>>>list = ['松','竹','梅']

>>>list[:] = ['歲寒三友']

#list[:]表示將列表的所有元素取出來

>>>print(list)

['歲寒三友']

#注意以下的錯誤做法：

>>>list = ['松','竹','梅']

>>>list[:] = '歲寒三友'

>>>print(list)

['歲', '寒', '三', '友']

列表的增加

列表的增加叫作列表的合並會更合理

#使用符號'+'

#符號'+'只能用在列表之間，不能用在列表和元素之間

>>>list1 = ['松']

>>>list2 = ['竹']

>>>list3 = ['梅']

>>>list = list1 + list2 +list3

>>>print(list)

['松', '竹', '梅']

列表的刪除

del

#刪除命令

>>>list = ['松','竹','梅']

>>>del list[:2]

>>>print(list)

['梅']

字典語法
字典數據的提取

#列表使用偏移量來提取，字典使用鍵來提取

>>>group = {'師父':'唐三藏', '大師兄':'孫行者', '二師兄':'豬八戒', '沙師弟':'沙和尚'}

>>>print(group['師父'])

唐三藏

字典數據的修改

>>>group = {'師父':'唐三藏', '大師兄':'孫行者', '二師兄':'豬八戒', '沙師弟':'沙和尚'}

>>>group['師父']='唐玄奘'

>>>print(group)

{'師父': '唐玄奘', '大師兄': '孫行者', '二師兄': '豬八戒', '沙師弟': '沙和尚'}

字典數據的增加

>>>group = {'師父':'唐三藏', '大師兄':'孫行者', '二師兄':'豬八戒', '沙師弟':'沙和尚'}

>>>group['白龍馬']='敖烈'

>>>print(group)

{'師父': '唐三藏', '大師兄': '孫行者', '二師兄': '豬八戒', '沙師弟': '沙和尚', '白龍馬': '敖烈'}

字典數據的刪除

>>>group = {'師父':'唐三藏', '大師兄':'孫行者', '二師兄':'豬八戒', '沙師弟':'沙和尚'}

>>>del group['師父']

>>>print(group)

{'大師兄': '孫行者', '二師兄': '豬八戒', '沙師弟': '沙和尚'}

dict.keys()

#提取字典中所有的鍵

>>>group = {'師父':'唐三藏', '大師兄':'孫行者', '二師兄':'豬八戒', '沙師弟':'沙和尚'}

>>>print(group.keys())

dict_keys(['師父', '大師兄', '二師兄', '沙師弟'])

#列印出了所有字典的鍵，但是都是元組的形式

>>>group = {'師父':'唐三藏', '大師兄':'孫行者', '二師兄':'豬八戒', '沙師弟':'沙和尚'}

>>>print(list(group.keys()))

['師父', '大師兄', '二師兄', '沙師弟']

#通過list()函數將元組轉化為列表的形式

dict.values()

#提取字典中所有的值

>>>group = {'師父':'唐三藏', '大師兄':'孫行者', '二師兄':'豬八戒', '沙師弟':'沙和尚'}

>>>print(group.values())

dict_values(['唐三藏', '孫行者', '豬八戒', '沙和尚'])

dict.items()

#提取字典中所有的鍵值對

>>>group = {'師父':'唐三藏', '大師兄':'孫行者', '二師兄':'豬八戒', '沙師弟':'沙和尚'}

>>>print(group.items())

dict_items([('師父', '唐三藏'), ('大師兄', '孫行者'), ('二師兄', '豬八戒'), ('沙師弟', '沙和尚')])

產生布爾值的表達式
bool()

#檢查數值的真假

>>>print(bool(1))

True

值本身作為條件

假的 其他都是真的
False True
0 5（任意整數）1.0（任意浮點數）
''（空字元串） '風變編程'（字元串）
[]（空列表） [1,2,3]
{}（空字典） {1:'a',2:'b'}
None
比較運算符產生布爾值

運算符 釋義 作用
== 等於 如果兩側的值相等，條件為真
!= 不等於 如果兩側的值不相等，條件為真
> 大於 如果左側的值大於右側，條件為真
< 小於 如果左側的值大於右側，條件為真
>= 大於等於 如果左側的值大於或等於右側，條件為真
<= 小於等於 如果左側的值小於或等於右側，條件為真
注意：運算符之間不用空格，不可以寫成= =、> =
成員運算符產生布爾值

運算符 釋義 作用
in 屬於 如果值在指定序列里，條件為真
not in 不屬於 如果值不在指定序列里，條件為真
邏輯運算符產生布爾值

運算符 釋義 作用
and 且 連接兩個布爾值，如果兩個都為真，該條件才為真
or 或 連接兩個布爾值，如果有一個為真，該條件即為真
not 非 反邏輯狀態，a為True，not a則為False，反之亦然
三、循環
for循環
for循環的基本格式是：for…in…

#遍歷字元串

>>>for i in 'coding':

... print(i)

c

o

d

i

n

g

#遍歷列表

>>>for i in ['for','change']

... print(i)

for

change

for…in dict:

#遍歷字典的鍵

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

>>>for i in list:

... print(i)

1

2

3

for…in dict.values():

#遍歷字典的值

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

>>>for i in list.values():

... print(i)

a

b

c

for…in dict.items():

#遍歷字典的鍵值對

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

>>>for k, v in list.items():

... print(k)

... print(v)

1

a

2

b

3

c

range()函數

#range()有最基本的三種用法：range(b)， range(a,b)，range(a,b,c)。

#函數中各個數值的意義：a：計數從a開始。不填時，從0開始；b：計數到b結束，但不包括b；c：計數的間隔，不填時默認為1。

>>>range(5)

#計數依次為0，1，2，3，4

>>>range(1,5)

#計數依次為1，2，3，4

>>>range(2,8,2)

#計數依次為2，4，6

for…in range()

#處理指定次數的循環

>>>for i in range(3):

... print('第%d遍風變編程' %i)

第0遍風變編程

第1遍風變編程

第2遍風變編程

while循環
while循環

#當條件為真時，執行循環語句，只要條件為真，便會一直循環

>>>count = 3

>>>while count > 1:

... print('happy coding')

... count = count -1

happy coding

happy coding

while循環和for循環的區別：

#for擅長處理固定次，自動遍歷各序列

#while處理不定次數的循環，條件為False便停止

循環進階
break

#如果滿足條件，則結束循環

>>>while True:

... print('happy coding')

... break

happy coding

#break會結束循環，如果只有前兩行代碼，會無限循環列印happy coding

>>>count = 3

>>>while count >1:

... print('happy coding')

... count = count - 1

... if count == 2: #當count等於2的時候，停止循環

... break

happy coding

#對比while循環的例子，我們發現這里只列印了一次happy coding

continue

#如果滿足條件，則跳過當前循環的剩餘語句，直接開始下一輪循環

count = 3

while count >1:

print('happy')

count = count - 1

if count == 2: #當count等於2的時候，跳過下列語句，重新開始新的一輪循環

continue

print('coding') #由於continue語句，coding只會列印一次

#列印的結果為：

happy

happy

coding

else

#無論是否進入循環，最後都會執行esle語句，除非執行break語句跳出循環

count = 3

while count >2:

print('在風變')

count = count -1

else: #無論是否進入循環都會執行else語句

print('happy coding')

#列印結果為：

在風變

happy coding

循環嵌套

#即循環中有循環

>>>for i in ['風變','編程']: #首先遍歷列表元素

... for t in i: #然後遍歷元素(字元串)

... print(t)

風

變

編

程

四、函數
函數基本知識
函數
函數是組織好的、可以重復使用的、用來實現單一功能的代碼

函數類型可分為自定義函數和內置函數，自定義函數是需要自己定義，而內置函數是python內部已經定義好的函數，比如print()、input()等

函數定義的語法
def

#定義函數

return

#函數的返回值

#函數定義的格式

def 函數名(參數)：

函數體

return 語句

#一個簡單的例子

def math_func(x):

y = x + 5

print(y)

return y

math_func(2)

#列印結果為7

變數作用域
變數作用域可認為是變數作用的范圍

全局變數：在全局內生效的變數

局部變數：只能函數內或者一定代碼塊內生效

global

#將局部變數轉化為局部變數

python內置函數
五、類與對象
概念
類：具有相同屬性和方法的對象的抽象

實例：類的個例

對象：Python中的對象是類和實例的集合，類可以看作是對象，實例也可以看作是對象

基本語法
class

#定義類，注意類名需要大寫

class MyClass: #定義類MyClass

i =12345 #定義類的屬性(變數)

def f(self): #定義類的方法

return('hello world') #執行這個方法會返回'hello word'這個字元串

x = MyClass() #創建類的實例x

print(x.i) #列印實例x的屬性

print(x.f()) #列印實例x的f方法

#輸出的結果為

12345

hello world

class A(B)

#定義B類的子類A類，A類具有B類的屬性和方法，也將B類稱為A類的父類

class SecondClass(MyClass):

pass

#定義SecondClass是MyClass的子類，SecondClass可以調用MyClass的屬性和方法

x = SecondClass()

print(x.i)

print(x.f())

#輸出的結果為

12345

hello world

class A(B, C)

#多重繼承，A類同時是B類和C類的子類，A類在調用屬性和方法的時候，會優先調用位於左側的類

class B:

i = 123 #B類的屬性是i=123

class C:

i = 12345 #C類的屬性是i=12345

class A(B,C): #A類是B類和C類的子類

pass

x = A() #創建A類的實例x

print(x.i) #調用屬性,會優先調用B類的屬性

#結果輸出為

123

def __init__(self):

#創建類的初始化方法，只要調用類，便自動調用初始化方法的語句，常用於創建實例屬性

>>>class A:

... def __init__(self): #只要創建實例，便會自動執行初始化方法下的語句

... print('hello world')

>>>x = A()

hello world #只要創建實例就會調用方法,列印hello world

#對比以下沒有初始化的方法：

>>>class A:

... def f(self):

... print('hello world')

>>>x = A()

#不使用初始化方法，創建實例無任何輸出

super()

#在子類的方法里調用父類的方法，使子類的方法可以在繼承父類方法的基礎上進行擴展

123 def super(cls, inst): mro = inst.__class__.mro() return mro[mro.index(cls) + 1]
cls代表類，inst代表實例，可以看出上面的代碼做了兩件事：

· 獲取inst的MRO列表。

· 查找cls在MRO的index，並返回它的下一個類，即mro[index + 1]

當你使用super(cls, inst)時，python會在inst的MRO列表上搜索下cls的下一個類。

六、模塊與庫
模塊類型
內置模塊

#python官方組織編寫和維護的模塊

自定義模塊

#自己寫代碼，然後將代碼塊保存為 .py 文件

第三方模塊

#從自定義模塊而來，代碼寫作者公開自己的代碼

#根據模塊的組織形式的不同，也可分為單個模塊文件、模塊包、模塊庫

模塊和模塊對象導入方法
import A

#導入模塊A

#現在可以調用模塊里函數和變數，但是必須通過【模塊名.函數名()】和【模塊名.變數名】的方式調用

#創建類實例的時候，需要使用【實例名 = 模塊名.類名()】進行創建，創建實例後調用類方法和屬性可以使用【實例名.函數名()】和【實例名.變數名】

import A as a

#導入模塊A，並將模塊A重新命名為a

#調用模塊中的類、函數和變數如上述操作一樣

from A import B

#導入模塊A中的對象B

#調用對象B中的函數和變數可以不加模塊名

from A import B，C，D

#導入模塊A中的多個對象B，C，D

from A import *

#導入模塊A中的所有對象

if __name__=="__main__":

#當.py文件被直接運行時，if __name__=="__main__":之下的代碼塊將被運行

#當.py文件以模塊形式被導入時，if __name__=="__main__":之下的代碼塊不被運行

七、文件讀寫
文件讀寫三步驟
第一步，打開文件

第二步，讀（寫）文件

第三步，關閉文件

打開文件語法
open(file, mode, encoding)

#打開文件

f = open('/letter.txt', 'r', encoding = 'UTF-8')

with open() as…

#使用這種方式打開文件，可以不使用close()關閉文件

with open('/letter.txt', 'r', encoding = 'UTF-8') as f:

讀寫模式mode

模式mode 操作 若不存在 是否覆蓋
r 只能讀不能寫 報錯 -
rb 二進制只讀 報錯 -
r+ 可讀可寫 報錯 是
rb+ 二進制讀寫 報錯 是
w 只能寫不能讀 創建文件 是
wb 二進制只寫 創建文件 是
w+ 可讀可寫 創建文件 是
wb+ 二進制讀寫 創建文件 是
a 追加不能讀 創建文件 否，追加寫
ab 二進制追加不能讀 創建文件 否，追加寫
a+ 可讀可寫 創建文件 否，追加寫
ab+ 二進制追加可讀可寫 創建文件 否，追加寫
讀寫文件語法
read()

#讀取文件內容

with open('/letter.txt','r',encoding = 'UTF-8') as f:

content = f.read()

#以字元串的形式讀取文件內容，將文件內容賦值給變數content

readlines()

#以列表的方式讀取文件內容

with open('/letter.txt','r',encoding = 'UTF-8') as f:

content = f.readlines()

#以列表的形式讀取文件內容，將文件內容賦值給變數content

write()

#清空文件內容，並寫入字元串入內容

with open('/letter.txt','r',encoding = 'UTF-8') as f:

f.write('python')

writelines()

#清空文件內容，以列表的方式寫入

with open('/letter.txt','r',encoding = 'UTF-8') as f:

f.writelines('python')

關閉文件語法
close()

#關閉文件

csv文件讀寫的相關函數

reader()

#讀取csv文件的函數

import csv #導入csv模塊

with open('letter.csv') as f:

reader = csv.reader(f) #讀取csv文件，將文件內容賦值到reader

writer()

#將內容寫入csv文件

writerow()

#寫入一行內容

writerows()

#一次寫入多行csv文件

import csv #導入csv模塊

with open('letter.csv','w',newline = '') as f:

writer = csv.writer(f) #寫入csv文件

writer.writerow(['python小課'，'風變編程']) #寫入一行內容

data = [['互動式學習'，'更簡單'],['助教醬醬','為你答疑解惑']]

writer.writerows(data) #寫入多行內容

os模塊

os.getcwd()

#返回當前的工作目錄

八、debug
try…except…語句

用於處理

for i in range(6):

try:

print(6/i)

#使用6依次除於0，1，2，3，4，5，並列印

except ZeroDivisionError

#除非發生ZeroDivisionError類型的錯誤，執行下列語句

print('0是不能做除數的！')

九、其他
str.spilt()

#返回一個由字元串內單片語成的列表

>>>'1,2,3'.split()

['1',',','2',',','3']

>>>'1,2,3'.split('?,')

['1','2','3']

random模塊

#隨機模塊

import random

#需要先導入random模塊，然後再調用相應方法

print(random.randint(1,10)) # 產生 1 到 10 的一個整數型隨機數

print(random.random()) # 產生 0 到 1 之間的隨機浮點數

print(random.uniform(1.1,5.4)) # 產生 1.1 到 5.4 之間的隨機浮點數，區間可以不是整數

print(random.choice('tomorrow')) # 從序列中隨機選取一個元素

print(random.randrange(1,100,2)) # 生成從1到100的間隔為2的隨機整數

轉義字元

轉義字元 意義
a 響鈴(BEL)
b 退格(BS)，將當前位置移到前一列
f 換頁(FF)，將當前位置移到下頁開頭
n 換行(LF)，將當前位置移到下一行開頭
r 回車(CR)，將當前位置移到本行開頭
t 水平製表(HT) (跳到下一個TAB位置)
v 垂直製表(VT)
代表一個反斜杠字元""
' 代表一個單引號(撇號)字元
" 代表一個雙引號字元
? 代表一個問號
0 空字元(NUL)
ddd 1到3位八進制所代表的任意字元
xhh 1到2位十六進制所代表的任意字元
注意1：區分斜杠「/」和反斜杠「」，此處不可互換。注意2：以上表格內容也不需要硬記。

④ python下標是什麼

PYTHON中的下標是理解為可迭代對象中的序列對象進行切片時以0為起點的偏移量。

⑤ Python序列,集合,映射在數據關系層面的含義是什麼

序列：可通過偏移量來進行切片的對象。列表、元組、字元串都屬於序列。

散列：無法通過偏移量來進行切片的對象。比如 集合、字典。

Python內置的一種數據類型是列表：list。list是一種有序的集合，可以隨時添加和刪除其中的元素。

比如，列出班裡所有同學的名字，就可以用一個list表示：

>>> classmates = ['Michael', 'Bob', 'Tracy']

>>> classmates

['Michael', 'Bob', 'Tracy']

另一種有序列表叫元組：tuple。tuple和list非常類似，但是tuple一旦初始化就不能修改，比如同樣是列出同學的名字：

>>> classmates = ('Michael', 'Bob', 'Tracy')

(5)python偏移量擴展閱讀：

Python的表達式寫法與C/C++類似。只是在某些寫法有所差別。

主要的算術運算符與C/C++類似。+, -, *, /, //, **, ~, %分別表示加法或者取正、減法或者取負、乘法、除法、整除、乘方、取補、取余。>>, <<表示右移和左移。&, |, ^表示二進制的AND, OR, XOR運算。>, <, ==, !=, <=, >=用於比較兩個表達式的值，分別表示大於、小於、等於、不等於、小於等於、大於等於。在這些運算符裡面，~, |, ^, &, <<, >>必須應用於整數。

Python使用and, or, not表示邏輯運算。

is, is not用於比較兩個變數是否是同一個對象。in, not in用於判斷一個對象是否屬於另外一個對象。

⑥ Python入門教程08——字元串操作

Python 提供了5個字元串操作符：in、空格、加號、星號和逗號。

字元串是字元的有序集合，可用in 操作符判斷字元串包含關系，例如：

以空格分隔（或者沒有分隔符號）的多個字元串可自動合並，例如：

加號可將多個字元串合並，例如：

星號用於將字元串復制多次以構成新的字元串，例如：

在使用逗號分隔字元串時，會創建字元串組成的元組，例如：

字元串是一個有序的集合，其中的每個字元可通過偏移量進行索引或分片。字元串中的字元按從左到右的順序，偏移量依次為： 0 、 1 、 2 … len-1 (最後一個字元的偏移量為字元串長度減1)；或者倒著排，為： -len … -2 、 -1 。索引指通過偏移量來定位字元串中的單個字元，例如：

通過索引可獲得指定位置的單個字元，但不能通過索引來修改字元串。因為字元串對象不允許被修改，例如：

字元串的切片利用索引范圍從字元串中獲得連續的多個字元（即子字元串）。字元串切片的基本格式如下：

表示返回字元串x中從偏移量start開始，到偏移量end之前的子字元串。 start和end參數均可省略，start默認為0,end默認為字元串長度。例如：

默認情況下，切片用於返回字元串中的多個連續字元，可以通過步長參數來跳過中間的字元，其格式如下：

用這種格式切片時，會依次跳過中間step-1個字元，step默認為1。請看如下代碼：

⑦ Python文件讀取中：f.seek(0)和f.seek(0,0)有什麼區別

seek(0)和f.seek(0,0)是沒有區別的。

file.seek()方法標准格式是：seek(offset,whence=0)offset：開始的偏移量，也就是代表需要移動偏移的位元組數whence：給offset參數一個定義，表示要從哪個位置開始偏移；0代表從文件開頭開始算起，1代表從當前位置開始算起，2代表從文件末尾算起。默認為0

whence 的默認參數是0。

whence 還有兩種情況 是1，或者2：

1的時候,相對當前坐標的移動，可以是正的也可以是負的。

2的時候相對於文件結束的移動，通常應該是負的。

(7)python偏移量擴展閱讀

python 文件讀寫操作：

讀文件

打開一個文件用open()方法(open()返回一個文件對象，它是可迭代的)：

>>> f = open('test.txt', 'r')

r表示是文本文件，rb是二進制文件。（這個mode參數默認值就是r）

如果文件不存在，open()函數就會拋出一個IOError的錯誤，並且給出錯誤碼和詳細的信息告訴你文件不存在：

>>> f=open('test.txt', 'r')
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
FileNotFoundError: [Errno 2] No such file or directory: 'test.txt'

文件使用完畢後必須關閉，因為文件對象會佔用操作系統的資源，並且操作系統同一時間能打開的文件數量也是有限的

>>> f.close()

由於文件讀寫時都有可能產生IOError，一旦出錯，後面的f.close()就不會調用。

⑧ python中什麼是序列，列表，元組，字元串，索引，區別是什麼

python中什麼是序列，列表檔滑，元組，字元串，索引，區別是什麼？

序列：可通過偏移量來進行切片的對象。列表、元組、字行塌臘符串都屬於序列。
散列：無法通過偏移量來進行切片的對象。比如 *** 、字典

序列包括：列表、元組、字元串
列表：是最常用的數組，可以進行嵌套；
元組：相當於Enum，一旦創建，元組的值是不允許修改的；
字元串：顧名思義就是中英文字元以及標點符號等。
索引：序列中的每個元素被分配一個序號。注意索引默認從0開始。

python中列表，元組，字元串如何互相轉換

python中有三個內建函數：列表，元組和字元串，他們之間的互相轉換使用三個函數，str(),tuple()和list(),具體示例如下所示:>>> s = "xxxxx"
>>> list(s)
['x', 'x', 'x', 'x', 'x']
>>> tuple(s)
('x', 'x', 'x', 'x', 'x')
>>> tuple(list(s))
('x', 'x', 'x', 'x', 'x')
>>> list(tuple(s))
['x', 'x', 'x', 'x', 'x'] 列表和元組轉換為字元串則必須依靠join函數

1. str轉list
list = list(str)
2. list轉str
str= ''.join(list)
3. tuple list相互轉換
tuple=tuple(list)
list=list(tuple)

python中字元串方法isnumeric和isdigit的區別是什麼

isdigit()
True: Unicode數字，byte數字衫毀（單位元組），全形數字（雙位元組），羅馬數字
False: 漢字數字
Error: 無
isnumeric()
True: Unicode數字，全形數字（雙位元組），羅馬數字，漢字數字
False: 無
Error: byte數字（單位元組）

⑨ Python字典的底層實現

字典是一種可變、無序容器數據結構。元素以鍵值對存在，鍵值唯一。它的特點搜索速度很快：數據量增加10000倍，搜索時間增加不到2倍；當數據量很大的時候，字典的搜索速度要比列錶快成百上千倍。

在Python中，字典是通過散列表（哈希表）實現的。字典也叫哈希數組或關聯數組，所以其本質是數組（如下圖），每個 bucket 有兩部分：一個是鍵對象的引用，一個是值對象的引用。所有 bucket 結構和大小一致，我們可以通過偏移量來讀取指定 bucket。

定義一個字典 dic = {}，假設其哈希數組長度為8。

Python會根據哈希數組的擁擠程度對其擴容。「擴容」指的是:創造更大的數組，這時候會對已經存在的鍵值對重新進行哈希取余運算保存到其它位置；一般接近 2/3 時，數組就會擴容。擴容後，偏移量的數字個數增加，如數組長度擴容到16時，可以用最右邊4位數字作為偏移量。

計算鍵對象 name 的哈希值，然後比較哈希數組對應索引內的bucket是否為空，為空返回 None ，否則計算這個bucket的鍵對象的哈希值，然後與 name 哈希值比較，相等則返回 值對象 ，否則繼續左移計算哈希值。

注意：
1.鍵必須為可哈希的，如數字、元組、字元串；自定義對象需要滿足支持hash、支持通過 __eq__() 方法檢測相等性、若 a == b 為真，則 hash(a) == hash(b) 也為真。

2.字典的內存開銷很大，以空間換時間。
3.鍵查詢速度很快，列表查詢是按順序一個個遍歷，字典則是一步到位。
4.往字典裡面添加新鍵可能導致擴容，導致哈希數組中鍵的次序變化。因此，不要在遍歷字典的同時進行字典的修改。

⑩ seek函數用法python

參數offset--開始的偏移量，也就是代表需要移動偏移的位元組數whence：可選，默認值為0。
給offset參數一個定義，表示要從哪個位置開始偏移；0代表從文件開頭開始算起，1代表從當前位置開始算起，2代表從文件末尾算起。
file.seek(off,whence=0)：從文件中移動off個操作標記（文件指針），正往結束方向移動，負往開始方向移動。
如果設定了whence參數，就以whence設定的起始位為准，0代表從頭開始，1代表當前位置，2代表文件最末尾位置。