python3零基礎入門1（學習總結）

目錄

• • • 1、下載Python
    • 2、基礎使用
    • • 2.1、轉義符
      • 2.2、案例（input-if--else）
    • 一、基礎概念入門1：
    • • 1、assert 斷言
      • 2、查看list的使用方法：
      • 3、元組的使用方法：（tuple）
      • 4、字符串內置方法
      • 5、字符串格式化
      • 6、序列
      • 7、函數
      • • 7.1、內嵌函數和閉包
        • 7.2、lambda表達式（匿名函數）
      • 8、遞歸(recursion)
      • • 8.1、菲波那切數列
      • 9、遞歸——漢諾塔（步驟解析）
      • 10、字典（dict）
      • 11、集合（無序的）
      • 推導式
      • 12、文件
      • • 12.1、只讀的方式打開文件讀取
        • 12.2、讀寫的方式打開文件
        • 12.3、一個簡單的使用（分割生成文件）
      • 13、文件系統
      • • os模塊中關於文件/目錄常用的函數使用方法：
        • os.path模塊中關於路徑常用的函數使用方法
      • 正則表達式模式
    • 二、入門2

1、下載Python

1、登錄官網下載所需的版本包
以window7為例：
右鍵下載包（Windows x86-64 executable installer）以管理員身份運行

#!/usr/bin/python3

2、基礎使用

2.1、轉義符

在使用變量之前，需要對其先賦值。
變量名可以包括字母、數字、下劃線，不能以數字開頭
(\)轉義符 # 例: let\'s go
如果想打印路徑特殊字符比較多，字符串前加r即可。
例：D:\AIT\work\Software\xftp
可以使用

str = r‘D:\AIT\work\Software\xftp’

2.2、案例（input-if–else）

使用idle（Python的編輯器），ctrl+n新建一個編輯頁，f5運行

import 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的隨機整數
secret = random.randint(1,3)
print("隨機數為",secret)
print('--------草莓A工作---------')
temp = input("猜數字,請寫下一個數字：")
guess = int(temp)
while guess != secret:
temp = input("猜錯了，請再次輸入：")
guess = int(temp)
if guess == secret:
print("你竟然蒙對了！\n" + "诶呦，猜對了也沒有用！")
else:
if guess >secret:
print("數字大了")
else:
print("數字小了")
print("結束^_^")

一、基礎概念入門1：

1、assert 斷言

>>> assert 3>7 #(斷言：後面條件為假時，程序崩潰彈出異常AssertionError)
Traceback (most recent call last):
File "<pyshell#25>", line 1, in <module>
assert 3>4
AssertionError

2、查看list的使用方法：

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'fa', 'guess', 'i', 'list1', 'list2', 'list3', 'member', 'member2', 'random', 'secret', 'temp']
>>>

>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>>

dir() 函數不帶參數時，返回當前范圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。

>>> member = [1, 3, '好', 'stree’']
>>> member.append('好的') #追加一個到末尾
>>> member
[1, 3, '好', 'stree', 'sdfasdf']
>>>
>>> member.extend(['哦','啊']) #追加列表到末尾
>>> member
[1, 3, '好', 'stree', 'sdfasdf', '哦', '啊']
>>>
>>> member.insert(1,'hei') #插入到什麼位置
>>> member
[1, 'hei', 3, '好', 'stree', 'sdfasdf', '哦', '啊']
>>>
>>> member[2]
3
>>>
`>>> member.remove('啊') #刪除一個值
>>> member
[1, 'hei', 3, '好', 'stree', 'sdfasdf', '哦']
>>> ``
>>> del member[1] #刪除某一位的值
>>> member
[1, 3, '好', 'stree', 'sdfasdf', '哦']
>>>
>>> member.pop() # 函數用於移除列表中的一個元素（默認最後一個元素），並且返回該元素的值。
'哦'
>>> member
[1, 3, '好', 'stree', 'sdfasdf']
>>> member.pop(0) #也可以指定移出
1
>>> member
[3, '好', 'stree', 'sdfasdf']
>>> member[1:3] #拷貝出1到3位置的值不包括3，也可以使用member[:3]、member[1:]、member[:]
['好', 'stree']
>>> member
[3, '好', 'stree', 'sdfasdf']
>>> member[:3]
[3, '好', 'stree']
>>> member[1:]
['好', 'stree', 'sdfasdf']
>>> member[:]
[3, '好', 'stree', 'sdfasdf']
>>> member2 = member[:] # 拷貝。如果使用member2 = member的話member2會因member的變動而變動。
>>> member2
[3, '好', 'stree', 'sdfasdf']
>>>
>>> list1 = [123]
>>> list2 = [234]
>>> list1 < list2
True
>>> list1 = [123, 456]
>>> list2 = [234, 345]
>>> list1< list2 #比較第0位
True
>>> list1 * 3
[123, 456, 123, 456, 123, 456]
>>> 123 in list1
True
>>> 123 not in list1
False
>>> 1223 not in list1
True
>>>
>>> list3 = [123, ['你好', 123, 'hello'], 234]
>>> '你好' in list3
False
>>> '你好' in list3[1]
True
>>> list3[1]
['你好', 123, 'hello']
>>>
>>> list3[1][1]
123
>>>
>>> list3 *= 5
>>> list3
[123, ['你好', 123, 'hello'], 234, 123, ['你好', 123, 'hello'], 234, 123, ['你好', 123, 'hello'], 234, 123, ['你好', 123, 'hello'], 234, 123, ['你好', 123, 'hello'], 234]
>>> list3.count(123) #123在list中出現的次數
5
>>>
>>>
>>> list3 = [234, '你好', 123, 'hello']
>>> list3
[234, '你好', 123, 'hello']
>>>
>>> list3.reverse() #list中值反轉
>>> list3
['hello', 123, '你好', 234]
>>>
>>> list3.index(123) #返回參數在列表中的位置，取命中其中的第一個位置，默認所有范圍
1
>>>
>>> list3*=3
>>> list3
['hello', 123, '你好', 234, 'hello', 123, '你好', 234, 'hello', 123, '你好', 234]
>>> list3.index(123,3,7) # 查詢范圍3~7，中123的位置
5
>>>
>>> list4 = [0,2,3,5,4,7,6,3]
>>> list4.sort() # 排序從小到大
>>> list4
[0, 2, 3, 3, 4, 5, 6, 7]
>>> list4.sort(reverse=True) #逆序
>>> list4
[7, 6, 5, 4, 3, 3, 2, 0]

3、元組的使用方法：（tuple）

元組是不可改變的，不能增減排序

>>> tuple1 = (1,2,3,4,5,6,7,8)
>>> tuple1
(1, 2, 3, 4, 5, 6, 7, 8)
>>> tuple1[1]
2
>>> tuple1[3:]
(4, 5, 6, 7, 8)
>>> tuple2 = tuple1[:]
>>> tuple2
(1, 2, 3, 4, 5, 6, 7, 8)
>>>
>>> temp = (3,) #創建一個元組必須要有逗號
>>> type(temp) # 查看變量類型
<class 'tuple'>
>>>
>>> temp1 = (3)
>>> type(temp1)
<class 'int'>
>>>
>>> tuple1
(1, 2, 3, 4, 5, 6, 7, 8)
>>> tuple1 = tuple1[:2] + ('leo',) + tuple1[2:] #可以使用拼接進行更改，使用舊的元組拼接成新的元組（其實是更改tuple1指針位置，舊指針python過段時間會自動清理。）
>>> tuple1
(1, 2, 'leo', 3, 4, 5, 6, 7, 8)
>>>
>>> 8 * (8,) # 跟list一樣
(8, 8, 8, 8, 8, 8, 8, 8)
>>>

4、字符串內置方法

使用內置方法，原有的值不會變

>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>>
>>> str1 = 'I love you'
>>> str1.capitalize() # 首字母大寫
'I love you'
>>> str1.casefold() # 
'i love you'
>>> str1.center(40)
' I love you '
>>> str1.count('o')
2
>>> str1
'I love you'
>>>
>

字符串內置方法

方法解釋capitalize()# 把字符串的第一個字符改為大寫casefold()# 把整個字符串的所有字符改為小寫center(width)# 將字符串居中，並使用空格填充至長度 width 的新字符串count(sub[, start[, end]])# 返回 sub 在字符串裡邊出現的次數，start 和 end 參數表示范圍，可選。encode(encoding=‘utf-8’, errors=‘strict’)# 以 encoding 指定的編碼格式對字符串進行編碼。endswith(sub[, start[, end]])# 檢查字符串是否以 sub 子字符串結束，如果是返回 True，否則返回 False。start 和 end 參數表示范圍，可選。expandtabs([tabsize=8])# 把字符串中的 tab 符號（\t）轉換為空格，如不指定參數，默認的空格數是 tabsize=8。find(sub[, start[, end]])# 檢測 sub 是否包含在字符串中，如果有則返回索引值，否則返回 -1，start 和 end 參數表示范圍，可選。index(sub[, start[, end]])# 跟 find 方法一樣，不過如果 sub 不在 string 中會產生一個異常。isalnum()# 如果字符串至少有一個字符並且所有字符都是字母或數字則返回 True，否則返回 False。isalpha()# 如果字符串至少有一個字符並且所有字符都是字母則返回 True，否則返回 False。isdecimal()# 如果字符串只包含十進制數字則返回 True，否則返回 False。isdigit()# 如果字符串只包含數字則返回 True，否則返回 False。islower()# 如果字符串中至少包含一個區分大小寫的字符，並且這些字符都是小寫，則返回 True，否則返回 False。isnumeric()# 如果字符串中只包含數字字符，則返回 True，否則返回 False。isspace()# 如果字符串中只包含空格，則返回 True，否則返回 False。istitle()# 如果字符串是標題化（所有的單詞都是以大寫開始，其余字母均小寫），則返回 True，否則返回 False。isupper()# 如果字符串中至少包含一個區分大小寫的字符，並且這些字符都是大寫，則返回 True，否則返回 False。join(sub)# 以字符串作為分隔符，插入到 sub 中所有的字符之間。ljust(width)# 返回一個左對齊的字符串，並使用空格填充至長度為 width 的新字符串。lower()# 轉換字符串中所有大寫字符為小寫。lstrip()# 去掉字符串左邊的所有空格partition(sub)# 找到子字符串 sub，把字符串分成一個 3 元組 (pre_sub, sub, fol_sub)，如果字符串中不包含 sub 則返回 (‘原字符串’, ‘’, ‘’)replace(old, new[, count])# 把字符串中的 old 子字符串替換成 new 子字符串，如果 count 指定，則替換不超過 count 次。rfind(sub[, start[, end]])# 類似於 find() 方法，不過是從右邊開始查找。rindex(sub[, start[, end]])# 類似於 index() 方法，不過是從右邊開始。rjust(width)# 返回一個右對齊的字符串，並使用空格填充至長度為 width 的新字符串。rpartition(sub)# 類似於 partition() 方法，不過是從右邊開始查找。rstrip()# 刪除字符串末尾的空格。split(sep=None, maxsplit=-1)# 不帶參數默認是以空格為分隔符切片字符串，如果 maxsplit 參數有設置，則僅分隔 maxsplit 個子字符串，返回切片後的子字符串拼接的列表。-1表示整個都分割。splitlines(([keepends]))# 在輸出結果裡是否去掉換行符，默認為 False，不包含換行符；如果為 True，則保留換行符。。startswith(prefix[, start[, end]])# 檢查字符串是否以 prefix 開頭，是則返回 True，否則返回 False。start 和 end 參數可以指定范圍檢查，可選。strip([chars])# 刪除字符串前邊和後邊所有的空格，chars 參數可以定制刪除的字符，可選。swapcase()# 翻轉字符串中的大小寫。title()# 返回標題化（所有的單詞都是以大寫開始，其余字母均小寫）的字符串。translate(table)#根據 table 的規則（可以由 str.maketrans(‘a’, ‘b’) 定制）轉換字符串中的字符。upper()# 轉換字符串中的所有小寫字符為大寫。zfill(width)# 返回長度為 width 的字符串，原字符串右對齊，前邊用 0 填充。

5、字符串格式化

>>> "{0} love {1}.{2}".format("i","python","com")
'i love python.com'
>>> "{a} love {b}.{c}".format(a="i",b="python",c="com")
'i love python.com'
>>> "{
{1}}".format("不打印")
'{1}'
>>> '{0:.1f}{1}'.format(27.58,'GB') # 冒號標識格式化符號的開始，打印小數點後一位定點數
'27.6GB'
>>>
>>> '%c' '%c' '%c' % (97, 98, 99)
'abc'
>>> '%s' % 'i love you'
'i love you'
>>> '%d + %d - %d' % (5,5,1)
'5 + 5 - 1'
>>>
>>> '%o' % 10
'12'
>>> '%10d' % 10
' 10'
>>> '%010d' % 10
'0000000010'
>>> '%-010d' % 10
'10 '
>>>

字符串格式化符號含義

符號說明%c格式化字符及其 ASCII 碼%s格式化字符串%d格式化整數%o格式化無符號八進制數%x格式化無符號十六進制數%X格式化無符號十六進制數（大寫）%f格式化浮點數字，可指定小數點後的精度%e用科學計數法格式化浮點數%E作用同 %e，用科學計數法格式化浮點數%g根據值的大小決定使用 %f 或 %e%G作用同 %g，根據值的大小決定使用 %f 或者 %E

格式化操作符輔助命令

符號說明m.nm 是顯示的最小總寬度，n 是小數點後的位數-用於左對齊+在正數前面顯示加號（+）#在八進制數前面顯示 ‘0o’，在十六進制數前面顯示 ‘0x’ 或 ‘0X’0顯示的數字前面填充 ‘0’ 取代空格

Python 的轉義字符及其含義

符號說明\’單引號\"雙引號\a發出系統響鈴聲\b退格符\n換行符\t橫向制表符（TAB）\v縱向制表符\r回車符\f換頁符\o八進制數代表的字符\x十六進制數代表的字符\0表示一個空字符\\反斜槓

6、序列

>>> b = 'I love you'
>>> b
'I love you'
>>> b = list(b)
>>> b
['I', ' ', 'l', 'o', 'v', 'e', ' ', 'y', 'o', 'u']
>>> c = (1,1,2,3,4,8,13,21,34) #元組
>>> c = list(c) # 元組轉為列表
>>> c
[1, 1, 2, 3, 4, 8, 13, 21, 34]
>>>
>>> max(c)
34
>>> min(c)
1
>>> sum(c)
87
>>>
>>> c.append(2) # 末尾追加2
>>> sorted(c) # 排序，不改變源c序列
[1, 1, 2, 2, 3, 4, 8, 13, 21, 34]
>>>
>>> c
[1, 1, 2, 3, 4, 8, 13, 21, 34, 2]
>>> reversed(c) # 反轉，返回的是一個迭代器的對象
<list_reverseiterator object at 0x0000000002D1E430>
>>> list(reversed(c)) # 轉化為列表
[2, 34, 21, 13, 8, 4, 3, 2, 1, 1]
>>>
>>> c
[1, 1, 2, 3, 4, 8, 13, 21, 34, 2]
>>> enumerate(c)
<enumerate object at 0x000000000303AE00>
>>> list(enumerate(c)) # 枚舉
[(0, 1), (1, 1), (2, 2), (3, 3), (4, 4), (5, 8), (6, 13), (7, 21), (8, 34), (9, 2)]
>>>
>>> b
[3, 4, 6, 7, 8]
>>> list(zip(b,c)) # 打包
[(3, 1), (4, 1), (6, 2), (7, 3), (8, 4)]
>>>

7、函數

Python調用函數，如果上面沒有定義是無法調用的。

>>> def MyFirstFunction():
print('this is my first function')
print('再次表示感謝')
print('感謝CCTV')
>>> MyFirstFunction()
this is my first function
再次表示感謝
感謝CCTV
>>>
>>>
>>> def MySecondFunction(name, parameter):
'這個是函數文檔'
print(name + '我喜歡你的' + parameter)
>>> MySecondFunction.__doc__
'這個是函數文檔'
>>> MySecondFunction(name = 'leo', parameter='技術')
leo我喜歡你的技術
>>>
>>>
>>> def MySecondFunction(name='大家', parameter='能力'):
'這個是函數文檔'
print(name + '我喜歡你的' + parameter)
>>> MySecondFunction()
大家我喜歡你的能力
>>>
>>>
>>> def test(*params, exp = 8):
print('參數的長度是', len(params), exp);
print('第二位的參數是', params[1]);
>>> test(1,'leo',3,5,74)
參數的長度是 5 8
第二位的參數是 leo
>>>

例子1：

def MyFirstFunction(price , rate):
'這個是函數文檔'
old_price = 20
print('局部變量old_price：',old_price)
global count #定義全局變量
count = 10
final_price = price * rate
return final_price
old_price = float(input('請輸入原價：'))
print('全局變量old_price：',old_price)
rate = float(input('請輸入折扣率：'))
new_price = MyFirstFunction(old_price, rate) # 調用函數計算
print('打折後的價格是：', new_price)
print('自定義全局變量count使用global：',count)

例子1運行結果

====================== RESTART: F:/python-test/function.py =====================
請輸入原價：100
全局變量old_price： 100.0
請輸入折扣率：0.5
局部變量old_price： 20
打折後的價格是： 50.0
自定義全局變量count使用global： 10
>>>

7.1、內嵌函數和閉包

>>> def fun1():
x = 5
def fun2():
nonlocal x # 令x變量全局化
x *=x
return x
return fun2()
>>> fun1()
25
>>>

7.2、lambda表達式（匿名函數）

range

>>>range(10) # 從 0 開始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11) # 從 1 開始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5) # 步長為 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3) # 步長為 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 負數
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

以下是 range 在 for 中的使用，循環出runoob 的每個字母:

>>>x = 'runoob'
>>> for i in range(len(x)) :
... print(x[i])
...
r
u
n
o
o
b
>>>

內置函數filter過濾出從 0 開始到 9，10個數字中為奇數的數

>>> range(10) # 從 0 開始到 9
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(filter(None, [1, 0, False, True])) # 過濾出為不為None的
[1, True]
>>>
>>> temp = range(10)
>>> def odd(x):
return x % 2
>>> show = filter(odd, temp) # 過濾出為奇數的數字（不為偶數的數字）
>>> list(show)
[1, 3, 5, 7, 9]
>>>
>>> list(filter(lambda x : x % 2,range(10))) # 過濾出為奇數的數字（不為偶數的數字）。等同於上面的用法
[1, 3, 5, 7, 9]
>>>

內置函數map() 會根據提供的函數對指定序列做映射。
加工參數返回序列

>>> list(map(lambda x : x * 2, range(10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>>

8、遞歸(recursion)

例子1：求5的階乘(迭代)
迭代:是重復反饋過程的活動，其目的通常是為了逼近所需目標或結果。每一次對過程的重復稱為一次“迭代”，而每一次迭代得到的結果會作為下一次迭代的初始值。（循環）

def recursion(n):
result = n
for i in range(1, n):
result *= i
return result
number = int(input('請輸入一個正整數：'))
result = recursion(number)
print('%d 的階乘是：%d'% (number, result))

例子1的結果:

===================== RESTART: F:/python-test/recursion.py =====================
請輸入一個正整數：5
5 的階乘是：120
>>>

例子2：求5的階乘（遞歸）
遞歸，就是在運行的過程中調用自己。

def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n-1)
number = int(input('請輸入一個正整數：'))
result = factorial(number)
print('%d 的階乘是：%d'% (number, result))

例子2結果

===================== RESTART: F:/python-test/factorial.py =====================
請輸入一個正整數：5
5 的階乘是：120
>>>

8.1、菲波那切數列

迭代執行速度 > 遞歸執行速度
例子1：迭代實現

def fab(n):
n1 = 1
n2 = 1
n3 = 1
if n < 1:
print('輸入錯誤：')
return -1
while (n -2) > 0:
n3 = n2 + n1
n1 = n2
n2 = n3
n -= 1
return n3
num = int(input('請輸入數字：'))
result = fab(num)
if result != -1:
print('總共%d個小兔子' % result)

例子1結果：

======================= RESTART: F:/python-test/fab_1.py =======================
請輸入數字：30
總共有832040個小兔子誕生
>>>

例子2：遞歸實現（調用自身）數學函數思想

def fab(n):
if n < 1 :
print('輸入錯誤：')
return -1
if n==1 or n ==2:
return 1
else:
return fab(n-1) + fab(n-2)
num = int(input('請輸入數字：'))
result = fab(num)
if result != -1:
print('總共有%d個小兔子誕生' % result)

例子2：結果

======================= RESTART: F:/python-test/fab_2.py =======================
請輸入數字：30
總共有832040個小兔子誕生
>>>

9、遞歸——漢諾塔（步驟解析）

def hanoi(n, x , y, z):
if n == 1:
print(x, '-移動到->', z)
else:
hanoi(n-1, x, z, y) # 將前n-1個盤子從x移動到y上
print(x, '-移動到->', z) # 將最底下的最後一個盤子從x移動到z上
hanoi(n-1, y, x, z) # 將y上的n-1個盤子移動到z上
n = int(input('請輸入漢諾塔的層數：'))
hanoi(n, 'x左柱', 'y中柱', 'z右柱')

輸入4層結果：

====================== RESTART: F:/python-test/hannuota.py =====================
請輸入漢諾塔的層數：4
x左柱 -移動到-> y中柱
x左柱 -移動到-> z右柱
y中柱 -移動到-> z右柱
x左柱 -移動到-> y中柱
z右柱 -移動到-> x左柱
z右柱 -移動到-> y中柱
x左柱 -移動到-> y中柱
x左柱 -移動到-> z右柱
y中柱 -移動到-> z右柱
y中柱 -移動到-> x左柱
z右柱 -移動到-> x左柱
y中柱 -移動到-> z右柱
x左柱 -移動到-> y中柱
x左柱 -移動到-> z右柱
y中柱 -移動到-> z右柱
>>>

10、字典（dict）

key value

>>> dict1 = {
'李寧':'一切皆有可能','耐克':'jus do IT','阿迪達斯':'imossible is nohing'}
>>> print('耐克的口號是：',dict1['耐克'])
耐克的口號是： jus do IT
>>>
>>> dict2 = {
1:'ont', 2:'two', 3:'three'} # 創建一個字典
>>> dict2[2]
'two'
>>> dict3 = {
} #創建一個空的字典
>>> dict3
{
}
>>>
>>> dict3 = dict((('f',70), ('i',99), ('3',80),('4',9))) # 創建一個字典
>>> dict3
{
'f': 70, 'i': 99, '3': 80, '4': 9}
>>>
>>> dict4 = dict(你好='全世界', 電影='真好看') # 創建一個字典
>>> dict4
{
'你好': '全世界', '電影': '真好看'}
>>>
>>> dict4['電影'] = '是什麼' # 修改key對應的值
>>> dict4
{
'你好': '全世界', '電影': '是什麼'}
>>>
>>> dict4['小甲魚'] = '又是什麼' # 添加字典key -value
>>> dict4
{
'你好': '全世界', '電影': '是什麼', '小甲魚': '又是什麼'}
>>>

>>> dict1 = {
}
>>> dict1
{
}
>>> dict1.fromkeys((1,2,3,4))
{
1: None, 2: None, 3: None, 4: None}
>>> dict1 = dict1.fromkeys(range(32), '贊')
>>> dict1
{
0: '贊', 1: '贊', 2: '贊', 3: '贊', 4: '贊', 5: '贊', 6: '贊', 7: '贊', 8: '贊', 9: '贊', 10: '贊', 11: '贊', 12: '贊', 13: '贊', 14: '贊', 15: '贊', 16: '贊', 17: '贊', 18: '贊', 19: '贊', 20: '贊', 21: '贊', 22: '贊', 23: '贊', 24: '贊', 25: '贊', 26: '贊', 27: '贊', 28: '贊', 29: '贊', 30: '贊', 31: '贊'}
>>> for eachkey in dict1.keys(): # 打印keys
print(eachkey)
0
1
2
3
……
30
31
>>> for eachkey in dict1.values(): # 打印values
print(eachkey)
贊
贊
……
贊
>>> for eachkey in dict1.items(): # 打印所有的內容
print(eachkey)
(0, '贊')
(1, '贊')
(2, '贊')
(3, '贊')
……
(31, '贊')
>>> print(dict1[31])
贊
>>> print(dict1[32])
Traceback (most recent call last):
File "<pyshell#49>", line 1, in <module>
print(dict1[32])
KeyError: 32
>>>
>>> print(dict4.get(32)) # get獲取值
None
>>> dict4.get(32)
>>> print(dict1.get(3, 'meiyou')) # 有值的話正常打印獲取的 值
贊
>>> print(dict1.get(32, 'meiyou')) # 可以如果不存在的情況下返回‘沒有’
meiyou
>>>
>>> 31 in dict1 # 使用in查找成員是否存在
True
>>> 32 in dict1
False
>>>
>>> dict1.clear() # 清空字典
>>> dict1
{
}
>>>
#使用clear會清空相關的字典表，如果直接置空其他關聯的表數據依然存在，以下是例子
>>> a = {
'name', 'leo'}
>>> b = a
>>> b
{
'leo', 'name'}
>>> a = {
}
>>> a
{
}
>>> b
{
'leo', 'name'}
>>> a = b
>>> a.clear()
>>> b
set()
>>> a
set()
>>> a = {
1:'noe', 2:'two', 3:'three'}
>>> b = a.copy() # 拷貝
>>> b
{
1: 'noe', 2: 'two', 3: 'three'}
>>> c = a # 賦值，只是在相同的數據上貼了一個標簽
>>> c
{
1: 'noe', 2: 'two', 3: 'three'}
>>>
>>> id(a)
50054720
>>> id(b)
50329216
>>> id(c)
50054720
>>>
>>> c[4] = 'four'
>>> c
{
1: 'noe', 2: 'two', 3: 'three', 4: 'four'}
>>> a
{
1: 'noe', 2: 'two', 3: 'three', 4: 'four'}
>>> b
{
1: 'noe', 2: 'two', 3: 'three'}
>>>
>>> a.pop(4) # 指定彈出一個key value
'four'
>>> a
{
1: 'noe', 2: 'two', 3: 'three'}
>>> a.popitem() # 隨機彈出一個key value
(3, 'three')
>>> a
{
1: 'noe', 2: 'two'}
>>> a.setdefault('xiaobai') # 添加一個key
>>> a
{
1: 'noe', 2: 'two', 'xiaobai': None}
>>> a.setdefault(3, 'five') # 添加一個key value
'five'
>>> a
{
1: 'noe', 2: 'two', 'xiaobai': None, 3: 'five'}
>>> b = {
'小白': 'dog'}
>>> a.update(b) # b映射更新到另一個字典a中去
>>> a
{
1: 'noe', 2: 'two', 'xiaobai': None, 3: 'five', '小白': 'dog'}
>>>

11、集合（無序的）

是無序的，無法索引某一個元素。

>>> set1 = set([1,2,3,4,5,5,5]) #創建一個集合自動剔除重復的值
>>> set1
{
1, 2, 3, 4, 5}
>>>

不可變的集合：

>>> num3 = frozenset([1,2,3,4,5]) # 定義一個不可變的集合
>>> num3.add(0)
Traceback (most recent call last):
File "<pyshell#148>", line 1, in <module>
num3.add(0)
AttributeError: 'frozenset' object has no attribute 'add'
>>>

內置方法：

>>> num2 = {
1,2,3,4,5,6,7,8}
>>> num2
{
1, 2, 3, 4, 5, 6, 7, 8}
>>> 1 in num2
True
>>> 9 in num2
False
>>> num2.add(9) # 添加
>>> num2
{
1, 2, 3, 4, 5, 6, 7, 8, 9}
>>>
>>> num2.remove(1) # 移除
>>> num2
{
2, 3, 4, 5, 6, 7, 8, 9}
>>>

例子：如果想剔除列表中重復的數[1,2,3,4,5,5,3,2,1,0]
方法一
for循環判斷

>>> num1 = [1,2,3,4,5,5,3,2,1,0]
>>> num1
[1, 2, 3, 4, 5, 5, 3, 2, 1, 0]
>>> temp = []
>>> for each in num1:
if each not in temp:
temp.append(each)
>>> temp
[1, 2, 3, 4, 5, 0]
>>>

方法二
使用集合set函數自動剔除重復的數，但是集合是無序的，雖然剔除了重復的數但是結果是亂序的

>>> num1 = [1,2,3,4,5,5,3,2,1,0]
>>> num1
[1, 2, 3, 4, 5, 5, 3, 2, 1, 0]
>>> num1 = list(set(num1)) # 使用集合set函數自動剔除重復的數，但是集合是無序的，雖然剔除了重復的數但是結果是亂序的
>>> num1
[0, 1, 2, 3, 4, 5]
>>>

推導式

列表推導式

[x*y for x in range(1,5) if x > 2 for y in range(1,4) if y < 3]

他的執行順序是:

for x in range(1,5)
if x > 2
for y in range(1,4)
if y < 3
x*y

>>> # 列表推導式
>>> a = [i for i in range(100) if not(i % 2) and i % 3]
>>> a
[2, 4, 8, 10, 14, 16, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46, 50, 52, 56, 58, 62, 64, 68, 70, 74, 76, 80, 82, 86, 88, 92, 94, 98]
>>> # 字典推導式
>>> b = {
i:i %2 ==0 for i in range(10)}
>>> b
{
0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}
>>> # 集合推導式
>>> c = {
i for i in [1, 1, 2, 3, 4, 5, 5, 6, 7, 3, 2, 1]}
>>> c
{
1, 2, 3, 4, 5, 6, 7}

12、文件

文件打開模式：

打開模式執行操作‘r’以只讀方式打開文件（默認）‘w’以寫入的方式打開文件，會覆蓋已存在的文件‘x’如果文件已經存在，使用此模式打開將引發異常‘a’以寫入模式打開，如果文件存在，則在末尾追加寫入‘b’以二進制模式打開文件‘t’以文本模式打開（默認）‘+’可讀寫模式（可添加到其他模式中使用）‘U’通用換行符支持

文件對象方法：

文件對象方法執行操作f.close()關閉文件f.read([size=-1])從文件讀取size個字符，當未給定size或給定負值的時候，讀取剩余的所有字符，然後作為字符串返回f.readline([size=-1])從文件中讀取並返回一行（包括行結束符），如果有size有定義則返回size個字符f.write(str)將字符串str寫入文件f.writelines(seq)向文件寫入字符串序列seq，seq應該是一個返回字符串的可迭代對象f.seek(offset, from)在文件中移動文件指針，從from（0代表文件起始位置，1代表當前位置，2代表文件末尾）偏移offset個字節f.tell()返回當前在文件中的位置f.truncate([size=file.tell()])截取文件到size個字節，默認是截取到文件指針當前位置

12.1、只讀的方式打開文件讀取

>>> f = open('F:\\python-test\\文件\\心經.txt') # 打開文件
>>> f.read(5) # 讀取文件內容，如果不給定值讀取所有，指針放到最後
'心經原文 '
>>> f.tell() # 返回所在位置
9
>>> f.seek(2, 0) # 在文件中移動文件指針f.seek(offset, from)（0代表文件起始位置，1代表當前位置，2代表文件末尾）偏移offset個字節
2
>>> f.readline() # 從文件中讀取並返回一行
'經原文 \u3000 \n'
>>> f.seek(0,0) # 指針放到開始位置
0
# 可轉成列表形式讀取
>>> lines = list(f)
>>> for each_line in lines:
print(each_line)
心經原文
……
# 官方推薦直接迭代讀取（高效）
>>> f.seek(0,0)
0
>>> for each_lin in f:
print(each_lin)
心經原文
……

12.2、讀寫的方式打開文件

>>> f = open('F:\\python-test\\文件\\心經.txt','w')
>>> f.tell()
0
>>> f.write('I love hello wold') # 以寫入的方式打開文件，會覆蓋已存在的文件
17
>>> f.close()
>>>
>>> f = open('F:\\python-test\\文件\\心經.txt','a') # 以寫入模式打開，如果文件存在，則在末尾追加寫入
>>> f.read()
>>> f.write('I love hello wold')
17
>>> f.close()

12.3、一個簡單的使用（分割生成文件）

test.txt

你好：I love hello wold1
不好：I love hello wold2
你好：I love hello wold3
不好：I love hello wold4
你好：I love hello wold5
=======================
不好：I love hello wold6
你好：I love hello wold7
不好：I love hello wold8
你好：I love hello wold9
=======================
不好：I love hello wold0
你好：I love hello wold~
不好：I love hello wold!
你好：I love hello wold?
不好：I love hello wold。

按‘不好’、‘你好’：後的話分割存儲到不同的文件中，一個====分割成一個文件
F:/python-test/file.py

# 保存文件
def save_file(boy, girl ,count):
file_name_boy = 'F:\\python-test\\文件\\' + 'boy_' + str(count) + '.txt'
file_name_girl = 'F:\\python-test\\文件\\' + 'girl_' + str(count) + '.txt'
boy_file = open(file_name_boy, 'w') # 打開一個文件准備寫入
girl_file = open(file_name_girl, 'w')
boy_file.writelines(boy) #向文件寫入字符串“序列”
girl_file.writelines(girl)
boy_file.close()
girl_file.close()
# 分割文件
def split_file(file_name):
f = open(file_name)
boy = []
girl = []
count = 1
for each_line in f:
if each_line[:6] != '======':
# 我們這裡進行字符串分割
(role, line_spoken) = each_line.split('：', 1) # 分割一次,返回切片後的子字符串拼接的列表。
if role == '你好':
boy.append(line_spoken)
if role == '不好':
girl.append(line_spoken)
else:
# 文件分割保存，碰到'======'保存
save_file(boy, girl, count)
boy = []
girl = []
count += 1
save_file(boy, girl, count)
f.close()
split_file('F:\\python-test\\文件\\test.txt')

運行成功：

13、文件系統

import os

os模塊中關於文件/目錄常用的函數使用方法：

函數名使用方法getcwd()返回當前工作目錄chdir(path)改變工作目錄listdir(path=’.’)列舉指定目錄中的文件名（’.‘表示當前目錄，’…'表示上一級目錄）mkdir(path)創建單層目錄，如該目錄已存在拋出異常makedirs(path)遞歸創建多層目錄，如該目錄已存在拋出異常，注意：'E:\a\b’和’E:\a\c’並不會沖突remove(path)刪除文件rmdir(path)刪除單層目錄，如該目錄非空則拋出異常removedirs(path)遞歸刪除目錄，從子目錄到父目錄逐層嘗試刪除，遇到目錄非空則拋出異常rename(old, new)將文件old重命名為newsystem(command)運行系統的shell命令walk(top)遍歷top路徑以下所有的子目錄，返回一個三元組：(路徑, [包含目錄], [包含文件])以下是支持路徑操作中常用到的一些定義，支持所有平台os.curdir指代當前目錄（’.’）os.pardir指代上一級目錄（’…’）os.sep輸出操作系統特定的路徑分隔符（Win下為’\’，Linux下為’/’）os.linesep當前平台使用的行終止符（Win下為’\r\n’，Linux下為’\n’）os.name指代當前使用的操作系統（包括：‘posix’, ‘nt’, ‘mac’, ‘os2’, ‘ce’, ‘java’）

簡單使用：

>>> import os
>>> os.getcwd() # 獲取當前工作目錄
'F:\\python-test'
>>> os.chdir('F:\\python-test\\working') # 更改工作目錄
>>> os.getcwd()
'F:\\python-test\\working'
>>> os.listdir()
['fab_1.py', 'fab_2.py', 'factorial.py', 'file.py', 'function.py', 'hannuota.py', 'print(ifelse).py', 'recursion.py']
>>> os.makedirs('F:\\python-test\\working\\A\\B')
>>> os.listdir()
['A', 'fab_1.py', 'fab_2.py', 'factorial.py', 'file.py', 'function.py', 'hannuota.py', 'print(ifelse).py', 'recursion.py']
>>> os.curdir
'.'
>>> os.listdir(os.curdir)
['fab_1.py', 'fab_2.py', 'factorial.py', 'file.py', 'function.py', 'hannuota.py', 'print(ifelse).py', 'recursion.py']
>>>

os.path模塊中關於路徑常用的函數使用方法

函數名使用方法basename(path)去掉目錄路徑，單獨返回文件名dirname(path)去掉文件名，單獨返回目錄路徑join(path1[, path2[, …]])將path1, path2各部分組合成一個路徑名split(path)分割文件名與路徑，返回(f_path, f_name)元組。如果完全使用目錄，它也會將最後一個目錄作為文件名分離，且不會判斷文件或者目錄是否存在splitext(path)分離文件名與擴展名，返回(f_name, f_extension)元組getsize(file)返回指定文件的尺寸，單位是字節getatime(file)返回指定文件最近的訪問時間（浮點型秒數，可用time模塊的gmtime()或localtime()函數換算）getctime(file)返回指定文件的創建時間（浮點型秒數，可用time模塊的gmtime()或localtime()函數換算）getmtime(file)返回指定文件最新的修改時間（浮點型秒數，可用time模塊的gmtime()或localtime()函數換算）以下為函數返回 True 或 Falseexists(path)判斷指定路徑（目錄或文件）是否存在isabs(path)判斷指定路徑是否為絕對路徑isdir(path)判斷指定路徑是否存在且是一個目錄isfile(path)判斷指定路徑是否存在且是一個文件islink(path)判斷指定路徑是否存在且是一個符號鏈接ismount(path)判斷指定路徑是否存在且是一個掛載點samefile(path1, paht2)判斷path1和path2兩個路徑是否指向同一個文件

使用例子：

>>> os.path.basename('F:\\python-test\\working\\factorial.py')
'factorial.py'
>>> os.path.dirname('F:\\python-test\\working\\factorial.py')
'F:\\python-test\\working'
>>>
>>> os.listdir(os.path.dirname('F:\\python-test\\working\\'))
['fab_1.py', 'fab_2.py', 'factorial.py', 'file.py', 'function.py', 'hannuota.py', 'print(ifelse).py', 'recursion.py']
>>>
>>> os.path.split('F:\\python-test\\working\\factorial.py')
('F:\\python-test\\working', 'factorial.py')
>>>
>>> os.path.splitext('F:\\python-test\\working\\factorial.py')
('F:\\python-test\\working\\factorial', '.py')
>>> import time
>>> time.localtime(os.path.getatime('F:\\python-test\\working\\factorial.py'))
time.struct_time(tm_year=2020, tm_mon=11, tm_mday=5, tm_hour=15, tm_min=42, tm_sec=43, tm_wday=3, tm_yday=310, tm_isdst=0)
>>>
>>> os.path.exists('F:\\python-test\\working\\factorial.py')
True
>>> os.path.ismount('F:\\')
True
>>> os.path.ismount('F:\\python-test\\')
False
>>>

正則表達式模式

模式描述^匹配字符串的開頭$匹配字符串的末尾。.匹配任意字符，除了換行符，當re.DOTALL標記被指定時，則可以匹配包括換行符的任意字符。[…]用來表示一組字符,單獨列出：[amk] 匹配 ‘a’，‘m’或’k’[^…]不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。re*匹配0個或多個的表達式。re+匹配1個或多個的表達式。re?匹配0個或1個由前面的正則表達式定義的片段，非貪婪方式re{ n}匹配n個前面表達式。例如，"o{2}“不能匹配"Bob"中的"o”，但是能匹配"food"中的兩個o。re{ n,}精確匹配n個前面表達式。例如，"o{2,}“不能匹配"Bob"中的"o”，但能匹配"foooood"中的所有o。"o{1,}“等價於"o+”。"o{0,}“則等價於"o*”。re{ n, m}匹配 n 到 m 次由前面的正則表達式定義的片段，貪婪方式a| b匹配a或b(re)匹配括號內的表達式，也表示一個組(?imx)正則表達式包含三種可選標志：i, m, 或 x 。只影響括號中的區域。(?-imx)正則表達式關閉 i, m, 或 x 可選標志。只影響括號中的區域。(?: re)類似 (…), 但是不表示一個組(?imx: re)在括號中使用i, m, 或 x 可選標志(?-imx: re)在括號中不使用i, m, 或 x 可選標志(?#…)注釋.(?= re)前向肯定界定符。如果所含正則表達式，以 … 表示，在當前位置成功匹配時成功，否則失敗。但一旦所含表達式已經嘗試，匹配引擎根本沒有提高；模式的剩余部分還要嘗試界定符的右邊。(?! re)前向否定界定符。與肯定界定符相反；當所含表達式不能在字符串當前位置匹配時成功。(?> re)匹配的獨立模式，省去回溯。\w匹配數字字母下劃線\W匹配非數字字母下劃線\s匹配任意空白字符，等價於 [\t\n\r\f]。\S匹配任意非空字符\d匹配任意數字，等價於 [0-9]。\D匹配任意非數字\A匹配字符串開始\Z匹配字符串結束，如果是存在換行，只匹配到換行前的結束字符串。\z匹配字符串結束\G匹配最後匹配完成的位置。\b匹配一個單詞邊界，也就是指單詞和空格間的位置。例如， ‘er\b’ 可以匹配"never" 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。\B匹配非單詞邊界。‘er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。\n, \t, 等。匹配一個換行符。匹配一個制表符, 等\1…\9匹配第n個分組的內容。\10匹配第n個分組的內容，如果它經匹配。否則指的是八進制字符碼的表達式。

二、入門2

零基礎入門2

學習地址
資料地址

Pymongo