零基礎學Python，本文是我個人的隨心筆記，希望對你有益！
注釋：單行：#…… 多行：單引號（’’’） 雙引號（”””）
基本數據類型：整數：int；浮點數：float（只有這兩種）；str：字符串；bool：布爾類型；complete：復數；list:列表；tuple:元組；set:集合；dict:字典
1 >>> type(2) 2 <class 'int'> 3 >>> type(1.1) 4 <class 'float'> 5 >>> type(1+1.1) 6 <class 'float'> 7 >>> type(2/2) 8 <class 'float'> 9 >>> type(2//2) 10 <class 'float'> 11 >>> 2//2 12 1 13 >>> 2/2 14 1.0 15 >>> 2*2 16 4
type()用來獲取該表達式的數據類型
//: 除並取整
/ ：除之后商有一位小數
1 print("I", end=" ") 2 print("love ", end='') 3 print("you !") # I love you !（沒有換行）
進制轉換
1 >>> 0b10 # 二進制 2 2 3 >>> 0o10 # 八進制 4 8 5 >>> 0x10 # 十六進制 6 16 7 >>> bin(0o10) # 八進制 轉換 二進制 8 '0b1000' 9 >>> bin(10) # 十進制 轉換 二進制 10 '0b1010' 11 >>> bin(0x10) # 十六進制 轉換 二進制 12 '0b10000' 13 >>> int(0b10) # 二進制 轉換 八進制 14 2 15 >>> int(0o10) # 十進制 轉換 八進制 16 8 17 >>> int(0x10) # 十六進制 轉換 八進制 18 16 19 >>> hex(0b10) # 二進制 轉換 十六進制 20 '0x2' 21 >>> hex(0o10) # 八進制 轉換 十六進制 22 '0x8' 23 >>> hex(10) # 十進制 轉換 十六進制 24 '0xa'
布爾類型
1 # True和False首字母都要大寫 2 >>> type(True) 3 <class 'bool'> 4 >>> type(False) 5 <class 'bool'> 6 >>> int(True) 7 1 8 >>> int(False) 9 0 10 >>> bool(1) 11 True 12 >>> bool(0) 13 False 14 >>> bool(2) 15 True 16 >>> bool(2.2) 17 True 18 >>> bool(-2) 19 True 20 >>> bool('abc') 21 True 22 >>> bool('') 23 False 24 >>> bool([1,2,3]) 25 True 26 >>> bool([]) 27 False 28 >>> bool({1,2,3}) 29 True 30 >>> bool({}) 31 False 32 >>> bool(None) 33 False 34 >>> 36j # 輸出復數 35 36j
str(不可變)：字符串 -> 單引號，雙引號，三引號（成對出現）
1 >>> "let's go !" 2 "let's go !" 3 >>> ''' 4 ... 1 5 ... 2 6 ... a 7 ... b 8 ... ''' 9 '\n1\n2\na\nb\n' 10 >>> "let's go !" 11 "let's go !" 12 >>> ''' 13 ... 1 14 ... 2 15 ... a 16 ... b 17 ... ''' 18 '\n1\n2\n3\na\nb\n' 19 >>> """\n1\n2\na\nb\n""" 20 '\n1\n2\na\nb\n' 21 >>> print("""\n1\n2\n3\na\nb\n""") 22 23 1 24 2 25 3 26 a 27 b 28 29 結束
format格式化函數
1 >>> "{} {}".format("hello","world") # 不設置指定位置，按默認順序 2 'hello world' 3 >>> "{0} {1}".format("hello","world") # 設置指定位置 4 'hello world' 5 >>> "{1} {0} {1}".format("hello","world") # 設置指定位置 6 'world hello world' 7 >>> "網站名：{name}，地址：{url}".format(name="世界與你同在",url=" http://www.worldiwiu.ltd/main ") # 設置參數 8 '網站名：世界與你同在，地址：http://www.worldiwiu.ltd/main ' 9 >>> site = {"name": "世界與你同在", "url": " http://www.worldiwiu.ltd/main "} # 通過字典設置參數 10 >>> "網站名：{name}，地址：{url}".format(**site) # 通過**可講字典中的值分配給關鍵字參數 11 '網站名：世界與你同在，地址：http://www.worldiwiu.ltd/main ' 12 >>> list = ['世界與你同在',' http://www.worldiwiu.ltd/main '] 13 >>> "網站名：{0[0]}，地址：{0[1]}".format(list) # 通過列表索引設置參數；“0”是必須的 14 '網站名：世界與你同在，地址：http://www.worldiwiu.ltd/main '
關鍵字參數和默認值
像這樣使用名稱指定的參數稱為關鍵字參數，只要有點是有足浴澄清各個參數的作用
>>>store(patient=’Mr.Brainsample’,hour=10,minute=20,day=13,month=5)
雖然這樣做的輸入量多些，但每個參數的作用清晰明了。另外，參數的順序錯了也沒有關系，關鍵字參數最大的有點在於，可以指定默認值
1 def hello_1(getting,name): 2 print(‘{},{}!’.format(getting, name)) 3 >>>hello_1(name=’world’, getting=’Hello’) 4 Hello,world! 5 6 def hello_1(name,getting): 7 print(‘{},{}!’.format(name, getting)) 8 >>>hello_2(getting=’Hello’, name=’world’) 9 world,Hello! 10 11 def hello_3(getting=‘Hello’,name=‘world’): 12 print(‘{},{}!’.format(getting, name)) 13 # 參數設置默認值 14 >>>hello_3() 15 Hello,world! 16 >>>hello_3('I love', 'you ') 17 I love,you ! 18 >>>hello_3(name='xing') 19 Hello,xing! 20 21 def hello_4(name, getting='Hello', fuhao='!'): 22 print('{},{}{}'.format(getting, name, fuhao)) 23 >>>hello_4('xing') 24 Hello,xing! 25 >>>hello_4('興,今天過得好嗎', getting='你好', fuhao='?') 26 你好,興,今天過得好嗎?
收集參數
1 def print_params(*params): 2 print(params) 3 >>> print_params('Testing') 4 ('Testing',) 5 >>> print_params(1,2,3) 6 (1, 2, 3) 7 8 def print_params_2(title, *params): 9 print(title, end="") 10 print(params) 11 >>>print_params_2('Params:', 1, 2, 3) 12 Params:(1, 2,3)# *:收集余下的位置參數 13 14 def print_params_3(x, *y, z): 15 print(x, y, z) 16 >>>print_params_3(1, 2, 3, z=4) 17 1 (2, 3) 4 18 print_params_3(1, 2, 3, 4) 19 # 星號不會收集關鍵字參數 20 TypeError: print_params_3() missing 1 required keyword-only argument: 'z' 21 22 # 要收集關鍵字參數,可使用兩個星號 23 def print_params_4(**params): 24 print(params) 25 >>>print_params_4(x=1, y=2, z=3) 26 {'x': 1, 'y': 2, 'z': 3} 27 28 def print_params_5(x, y, a, z=4, *pospar, **keypar): 29 print(x, y, z, a) 30 print(pospar) 31 print(keypar) 32 print_params_5(1, 2, 0, 3, 4, 5, 7, 6, foo=9, bar=8) 33 1 2 3 0 34 (5, 7, 6) 35 {'foo': 9, 'bar': 8}
分配參數
1 def add(x, y): 2 return x + y 3 b=(2, 5) 4 print(add(*b)) # 顯示: 7 5 # 這與前面的操作差不多是相反:不是收集參數,而是分配參數。這是通過在調用函數(而不是定義函數)時使用運算符*實現的 6 params = {'name': '興', 'getting': '你好'} 7 hello_3(**params) # 你好,興!
轉義字符
| 轉義字符 |
描述 |
| \(在行尾時) |
續行符 |
| \\ |
反斜杠符號 |
| \' |
單引號 |
| \" |
雙引號 |
| \a |
響鈴 |
| \b |
退格(Backspace) |
| \e |
轉義 |
| \000 |
空 |
| \n |
換行 |
| \v |
縱向制表符 |
| \t |
橫向制表符 |
| \r |
回車 |
| \f |
換頁 |
| \oyy |
八進制數，yy代表的字符，例如：\o12代表換行 |
| \xyy |
十六進制數，yy代表的字符，例如：\x0a代表換行 |
| \other |
其它的字符以普通格式輸出 |
1 >>> print(r'I\nlove\nyou') # 加r之后，將輸出原始字符串 2 I\nlove\nyou 3 >>> print('I\nlove\nyou') 4 I 5 love 6 you
字符切片
1 >>> "hello word"[-0] 2 'h' 3 >>> "hello word"[0] 4 'h' 5 >>> "hello word"[2:5] 6 'llo' 7 >>> "hello word"[2:-1] 8 'llo wor' 9 >>> "I love you"[1] 10 ' ' # 空格也將會輸出 11 >>> "I love you"[2:] 12 'love you' 13 >>> "I love you"[-3:] 14 'you' 15 >>> "I love you"[:-1] 16 'I love yo' 17 >>> "I love you"[:-0] 18 '' 19 >>> "I love you"[:0] 20 '' 21 >>> ["I","love","you"][1:] 22 ['love', 'you'] 23 >>> ["I","love","you"][1:2]*3 24 ['love', 'love', 'love'] 25 >>> type(["I","love","you"]) 26 <class 'list'> 27 >>> (("I","love","you"))[1:] 28 ('love', 'you') 29 >>> "I love yuo I love you I love you"[2:15:3] 30 'leuIo' 31 >>> "I love yuo I love you I love you"[2::3] 32 'leuIo u vy' 33 # 2 :表示索引1； 15:表示索引2； 3 ：表示每隔三個輸出一個字符 34 >>> "love" in ["I","love","yuo"] 35 True 36 # 表達式1 in 表達式 => 表達式1是否在表達式2中
元組：( ) 列表：[ ] 字典：{ }（無序的，沒有索引，不可切片）
1 >>> type(set()) # 定義空的集合 2 <class 'set'> 3 >>> {1,2,3,4,5,6,7} - {3,4} # 差集 4 {1, 2, 5, 6, 7} 5 >>> {1,2,3,4,5,6,7} & {3,4} # 交集 6 {3, 4} 7 >>> {1,2,3,4,5,6,7} | {3,4} # 並集 8 {1, 2, 3, 4, 5, 6, 7}
位運算符
| & -> 與 |
| -> 或 |
^ -> 異或 |
- -> 取反 |
<< -> 左移動 |
>> -> 右移動 |
int str tuple （不可變）值類型 list set dict（可變）引用類型
成員資格運算符 in not in 測試該變量是否在該元組（列表、集合）中
相同運算符 is not is 比較變量是否是同一個對象
list：列表
| list01 = [1,2,3] list01.append(4) print("list01:", list01) list02 = list01 list03 = list01.copy() print("list02:", list02) list02[1] = 0 print("list03:", list03) print("list02:", list02) print("list01:", list01) list01.clear() list01[2:2] = [8] print("list03:", list03) print("list02:", list02) print("list01:", list01) |
list01: [1, 2, 3, 4]
list02: [1, 2, 3, 4]
list03: [1, 2, 3, 4] list02: [1, 0, 3, 4] list01: [1, 0, 3, 4] []
list03: [1, 2, 3, 4] list02: [1, 0, 8, 3, 4] list01: [1, 0, 8, 3, 4] |
append:用於將一個對象附加到列表末尾
=:這種復制（同一對象） copy：復制列表（兩個不同對象）
clear：清空該列表 在列表中插入一個元素 |
列表函數
| len() |
返回列表的長度 |
| max() |
返回列表中最大值 |
| min() |
返回列表中最小值 |
| list() |
用於將元組轉化為列表 |
列表方法
| append(object) |
用於將一個對象附加到列表末尾 |
1 >>> list01 = [1, 2, 3] 2 >>> list.append(4) 3 >>> list01.append(4) 4 >>> list01 5 [1, 2, 3, 4] |
| clear() |
清空列表的內容 |
1 >>> list01 = [1, 2, 3] 2 >>> list01.clear() 3 >>> list01 4 [] |
| copy() |
復制列表（復制成兩個不同對象） |
1 >>> list01 = [1, 2, 3, 4] 2 >>> list02 = list01.copy() 3 >>> list02 4 [1, 2, 3, 4] |
| count(value) |
計算指定的元素在列表中出現了多少次 |
1 >>> list01 = [1, 2, 3, 4, 1, 2, [3, 4], [1, 2, [3, 4]]] 2 >>> list01.count(3) 3 1 4 >>> list01.count([3, 4]) 5 1 |
| extend(list) |
能夠同時將多個值附加到列表末尾，為此可將這些值組成的序列作為參數提供給方法extend |
1 >>> list01 = [1, 2, 3, 4] 2 >>> list02 = [5, 6, 7, 8] 3 >>> list01 + list02 4 [1, 2, 3, 4, 5, 6, 7, 8] 5 >>> list01 6 [1, 2, 3, 4] 7 >>> list01.extend(list02) 8 >>> list01 9 [1, 2, 3, 4, 5, 6, 7, 8] |
| index(value) |
在列表中查找指定值第一次出現的索引 |
1 >>> list01 = ["1", "2", "3", "4"] 2 >>> list01.index('3') 3 2 |
| insert(index,object) |
用於將一個對象插入列表 |
1 >>> list01 = [1, 2, 4, 5] 2 >>> list01.insert(2,"three") 3 >>> list01 4 [1, 2, 'three', 4, 5] |
| pop([index]) |
從列表中刪除一個元素（末尾為最后一個元素），並返回該元素 （pop是唯一既修改列表有返回一個非None值的列表方法；使用pop可實現一種常見的數據結構——棧（stack），后進先出（LIFO）） |
1 >>> list01 = [1, 2, 3, 4] 2 >>> list01.pop() 3 4 4 >>> list01 5 [1, 2, 3] 6 >>> list01.pop(0) 7 1 8 >>> list01 9 [2, 3] |
| remove(value) |
用於刪除第一個為指定值的元素 |
1 >>> list01 = [1, 2, 3, 4, 2, 4, 3, 1] 2 >>> list01.remove(1) 3 >>> list01 4 [2, 3, 4, 2, 4, 3, 1] |
| reverse() |
按相反的順序排列列表中的元素（把列表元素反過來） |
1 >>> list01 = [1, 2, 3, 4] 2 >>> list01.reverse() 3 >>> list01 4 [4, 3, 2, 1] |
| sort() |
對列表進行升序排序 |
|
| sorted() |
對列表進行升序排序，或對字符串也可以進行排序操作 |
1 list_x = [2, 5, 6, 4, 3, 1, 8] 2 list_y = list_x.copy() 3 print("list_y:", list_y) # list_y: [2, 5, 6, 4, 3, 1, 8] 4 list_y.sort() 5 print("list_y:", list_y) # list_y: [1, 2, 3, 4, 5, 6, 8] 6 print("list_y:", list_y.sort()) # list_y: None(不能直接點sort()方法) 7 list_z = sorted(list_x) 8 print("list_z:", list_z) # list_z: [1, 2, 3, 4, 5, 6, 8] 9 print(sorted('Python')) # ['P', 'h', 'n', 'o', 't', 'y'] 10 list_x = ['2', '5', '6', '4', '3', '1', '8'] 11 list_y.sort(key=len, reverse=True) 12 print("list_y:", list_y) # list_y: ['1', '2', '3', '4', '5', '6', '8'] 13 list_y.sort(key=len) 14 print("list_y:", list_y) # list_y: ['1', '2', '3', '4', '5', '6', '8'] 15 list_y.sort(reverse=True) 16 print("list_y:", list_y) # list_y: ['8', '6', '5', '4', '3', '2', '1'] |
tuple:元組（不可變）
元組函數
| len() |
返回元組長度 |
| max() |
返回元組最大值 |
| min() |
返回元組最小值 |
| tuple() |
用於將列表轉換為元組 |
| sum() |
求元組中所有元素之和 |
dict:字典（無序）
格式：{key1 : value1, key2 : value2}
key：不可變的類型
1 >>> {'Q':'新月打擊','W':'蒼白之瀑','E':'月之降臨','R':'月神沖刺'}['Q'] 2 '新月打擊'
字典函數
| len(dict) |
計算字典元素個數 |
| str(dict) |
輸出字典以可打印的字符串表示 |
| type(variable) |
返回輸入的變量類型 |
字典方法
>>> dict = {} # 新建空字典
| clear() |
用於清除字典中的所有元素 |
|||
| copy() |
用於復制字典 |
|||
| get(key,[,d]) |
該方法中key是字典的鍵值，d是鍵值的默認值。若存在key就返回其值，否則返回d |
1 >>> dict.get("D","閃現") 2 '閃現' 3 >>> dict 4 {'Q': '新月打擊', 'W': '蒼白之瀑', 'E': '月之降臨', 'R': '月神沖刺'} |
||
| items() |
該方法使用字典中元素創建一個以(key,value)為一組的元組對象 |
1 >>> dict.items() 2 dict_items([('Q', '新月打擊'), ('W', '蒼白之瀑'), ('E', '月之降臨'), ('R', '月神沖刺')]) |
||
| keys() |
該方法使用字典中的鍵值來創建一個列表對象 |
1 >>> dict.keys() 2 dict_keys(['Q', 'W', 'E', 'R']) |
||
| values |
該方法使用字典中鍵值來創建一個列表對象 |
1 >>> dict.values() 2 dict_values(['新月打擊', '蒼白之瀑', '月之降臨', '月神沖刺']) |
||
| popitem() |
該方法用於刪除字典中的隨機一個元素 |
1 >>> dict.popitem() 2 ('R', '月神沖刺') 3 >>> dict 4 {'Q': '新月打擊', 'W': '蒼白之瀑', 'E': '月之降臨'} |
||
| setdefault(key[,d]) |
該方法中key是字典的鍵值，d是鍵值的默認值。若key存在，就返回其值，否則返回d |
1 >>> dict.setdefault("D","閃現") 2 '閃現' 3 >>> dict 4 {'Q': '新月打擊', 'W': '蒼白之瀑', 'E': '月之降臨', 'R': '月神沖刺', 'D': '閃現'} |
||
| update(E) |
該方法中E是字典對象，由字典對象E來更新此字典 |
1 >>> print(dict.update({"D":"閃現"})) 2 {'Q': '新月打擊', 'W': '蒼白之瀑', 'E': '月之降臨', 'R': '月神沖刺', 'D': '閃現'} |
||
| fromkeys() |
創建一個新字典，其中包括指定的鍵，且沒個鍵對應的值都是None |
1 >>> {}.fromkeys(['Q','W','E','R']) 2 {'Q': None, 'W': None, 'E': None, 'R': None} |
||
| values() |
返回一個由字典中的值組成的字典視圖 |
1 >>> d = {} 2 >>> d[1] = 1 3 >>> d[2] = 2 4 >>> d[3] = 3 5 >>> d.values() 6 dict_values([1, 2, 3]) |
先定義一個空字典
向字典中添加元素
輸出字典視圖 打印字典視圖 |
|
迭代器與生成器
迭代是Python最強大的功能之一，是訪問集合元素的一種方式
迭代器是一個可以記住遍歷的位置的對象
迭代器對象從集合的第一元素開始訪問，直到所有哦的元素被訪問完結束。迭代器只能往前不會后退
迭代器有兩個基本的方法：iter()和next()
StopItertion異常用於標識迭代的完成，防止出現無限 循環的情況，在__next__()方法中我們可以設置在完成指定循環次數后接觸發StopItertion異常來結束迭代。
生成器：
在Python中，使用了yield的函數被稱為生成器（generator）
跟普通函數不同的是，生成器是一個返回迭代器的函數，只能永不迭代操作，更簡單點理解生成器就是一個迭代器
在調用生成器運行的過程中，每次遇到yield時函數會暫停並保存當親所有的運行信息，返回yield的值，並在下一次執行next()方法是從當前位置繼續運行。
調用一個生成器函數，返回的是一個迭代器對象。
運算符的優先級
| 運算符說明 |
Python運算符 |
優先級 |
| 索引運算符 |
x[index]或x[index:index2[:index3]] |
18、19 |
| 屬性訪問 |
x.attrbute |
17 |
| 乘方 |
** |
16 |
| 按位取反 |
~ |
15 |
| 符號運算符 |
+或- |
14 |
| 乘、除 |
*、/、//、% |
13 |
| 加、減 |
+、- |
12 |
| 位移 |
>>、<< |
11 |
| 按位與 |
& |
10 |
| 按位異或 |
^ |
9 |
| 按位或 |
| |
8 |
| 比較運算符 |
==、!=、>、>=、<、<= |
7 |
| is運算符 |
is、is not |
6 |
| in運算符 |
in、not in |
5 |
| 邏輯非 |
not |
4 |
| 邏輯與 |
and |
3 |
| 邏輯或 |
or |
2 |
字符串
1 >>> a = "你好, %s, 你的房間號是%d。" 2 >>> b = ('張先生',102) 3 >>> a % b 4 '你好, 張先生, 你的房間號是102。'
| %% |
百分號標記 |
| %c |
字符及其ASCII碼 |
| %s |
字符串 |
| %d |
有符號整數（十進制） |
| %u |
無符號整數（十進制） |
| %o |
無符號整數（八進制） |
| %x |
無符號整數（十六進制） |
| %X |
無符號整數（十六進制大寫字符） |
| %e |
浮點數字（科學計數法 ） |
| %E |
浮點數字（科學計數法，用E代替e） |
| %f |
浮點數字（用小數點符號） |
| %g |
浮點數字（根據值的大小采用%e或%f） |
| %G |
浮點數字（類似於%g） |
| %p |
指針（用於十六進制打印值的內存地址） |
| %n |
存儲輸出字符的數量放進參數列表下一個變量中 |
符號
| 符號 |
說明 |
| m.n |
m是顯示的最小總寬度，n是小數點后的位數 |
| - |
用於左對齊 |
| + |
在正數前面顯示加號（+） |
| # |
在八進制數面前顯示‘0o’，在十六進制數前面顯示'0x‘或者’0X' |
| 0 |
顯示的數字前面填充‘0’取代空格 |
字符串方法、使用說明和案例
| 字符串方法 |
使用說明 |
案例 |
| capitalize() |
用於將字符串的第一個字母變成大寫，其他字母變成小寫 |
1 >>> str = "i Love you" 2 >>> str.capitalize() 3 'I love you' |
| count(String,start,end) |
用於統計字符串里某個字符出現的次數。可選參數為在字符串搜索的開始與結束位置 |
1 >>> s = 'o' 2 >>> str.count(s) 3 2 4 >>> str.count(s,0,5) 5 0 6 >>> str.count(s,0,12) 7 1 |
| find(String,start,end) |
用於檢測字符串中是否含子字符串。若含有子字符串，則返回開始的索引值；，否則返回 -1 還可以指定位置去查找子串 |
1 >>> str = "Python程序設計案例教程" 2 >>> s = "程序" 3 >>> str.find(s, 0, len(str)) 4 6 |
| index(String,start,end) |
用於檢測字符串中是否含子字符串。若含有，則返回開始索引值；否則會報一個異常 |
1 >>> str = "Python程序設計案例教程" 2 >>> s = "程序" 3 >>> str.index(s, 0, len(str)) 4 6 5 >>> str.index(s, 7, len(str)) 6 Traceback (most recent call last): 7 File "<stdin>", line 1, in <module> 8 ValueError: substring not found |
| isalnum() |
用於檢測字符串是否由漢字、字母和數字組成 |
1 >>> str = "Python程序設計案例教程" 2 >>> str.isalnum() 3 True 4 >>> str = "Python 程序設計案例教程" 5 >>> str.isalnum() 6 False # 該字符串有空格 |
| join(sequence) |
將序列中的元素用指定的字符連接生成一個新的字符串 |
1 >>> str = ("Python","程序","設計","案例","教程") 2 >>> s = "*" 3 >>> s.join(str) 4 'Python*程序*設計*案例*教程' |
| split() |
作用與join方法 相反 |
1 >>> str = "I love you !" 2 >>> str.split(" ") 3 ['I', 'love', 'you', '!'] |
| isalpha() |
用於檢測字符串是否 只有字母和漢字組成 |
1 >>> str = "Python程序設計案例教程" 2 >>> str.isalpha() 3 True 4 >>> str = "Python 程序設計案例教程" 5 >>> str.isalpha() 6 False # 該字符串有空格 |
| isdigit() |
用於檢測字符串是否只由數字組成 |
1 >>> str = "Python程序設計案例教程" 2 >>> str.isdigit() 3 False 4 >>> str = "1314520" 5 >>> str.isdigit() 6 True |
| lower() |
將字符全部轉化為小寫 |
1 >>> str = "i Love you" 2 >>> str.lower() 3 'i love you' |
| swapcase() |
講字符串大小寫互換 |
1 >>> str = "I Love You !" 2 >>> str.swapcase() 3 'i lOVE yOU !' |
| upper() |
將字符全部轉化為大寫 |
1 >>> str = "i Love you !" 2 >>> str.upper() 3 'I LOVE YOU !' |
| min() |
字符串最小值 |
1 >>> str = "I love you !" 2 >>> min(str) 3 ' ' |
| max() |
字符串最大值 |
1 >>> str = "I love you !" 2 >>> max(str) 3 'y' |
| len() |
計數字符串個數 |
1 >>> str = "I love you !" 2 >>> len(str) 3 12 |
| title() |
“標題化”該字符串 |
1 >>> str = "I love you !" 2 >>> str.title() 3 'I Love You !' |
| replace(old,new[,max]) |
用於把字符串中的舊字符串替換成新的字符串 max: 表示替換不超過max次 |
1 >>> str = "I do not love you !" 2 >>> str.replace(" do not "," ") 3 'I love you !' |
| translate() |
用法和replace方法相同，但不同的的是它只能替換一個字符 |
1 >>> str = "I love you !" 2 >>> str.translate(str.maketrans('LY','ly')) 3 'I love you !' |
| center() |
通過在兩邊添加填充字符（默認為空格）讓字符串居中 |
1 >>> str = "I love you !" 2 >>> s = "*" 3 >>> str.center(20,s) 4 '****I love you !****' |
| strip() |
去除字符串開頭和末尾的空格 |
1 >>> str = " I love you ! " 2 >>> str.strip() 3 'I love you !' |
導包
| 導包 |
說明 |
| from math import * sqrt(9) |
第一種導包 后面用起來更簡潔 |
| from math import sqrt,pow,floor |
第二種導包（可同時導入多個包） |
| import math math.sqrt(9) |
第三種導包 |
| import math as shuxue shuxue.sqrt(9) |
導包同時可以用(as)重命名 |
| from math as shuxue import * |
沒有這種，會報錯 |
| from math import pow as pf pf(2,3) pow(2,3) |
導入特定的函數並給它指定別名 |
賦值
| 賦值 |
說明 |
||
| 序列解包 |
|||
| >>> x,y,z = 1,2,3 >>> print(x,y,z) 1 2 3 |
一起賦多個值 |
||
| >>> x,y,z = 1,2,3 >>> x,y = y,x >>> print(x,y,z) 2 1 3 |
兩個變量值簡易交換 |
||
1 >>> a,b,*rest = [1, 2, 3, 4] 2 >>> rest # [3, 4] 3 >>> a # 1 4 >>> b # 2 5 >>> c,d = rest 6 >>> c # 3 7 >>> d # 4 |
星號運算符（*）來收集多余的值，這樣無需確保值和變量的個數相同 |
||
| 鏈式賦值 |
|||
1 >>> a = b = [1, 2] 2 >>> a == b 3 True 4 >>> a is b 5 True |
同等效果 |
1 >>> a = [1, 2] 2 >>> a = b 3 >>> a == b 4 True 5 >>> a is b 6 True |
|
1 >>> a = [1, 2] 2 >>> b = [1, 2] 3 >>> a == b 4 True 5 >>> a is b 6 False |
這樣不是同一對象 |
||
常見語句
| 語句 |
說明 |
| pass |
空語句，主要為了保持結構的完整性。pass不做任何事情，一般用做占位語句 |
| continue |
跳出本次循環，執行下一次循環 |
| break |
終止循環 |
常用方法
| 函數 |
說明 |
案例 |
| range |
tart：計數從start開始。默認是從0開始。例如：range(5)等價於range(0,5) stop：計數到stop結束，但不包括stop。例如：range(0, 5)是[0, 1, 2, 3, 4]沒有5 step：步長，默認為1。例如：range(0,5)等價於range(0,5,1) |
1 print("乘法口訣表：") 2 for x in range(1, 10): 3 for y in range(1, x+1): 4 print(y, "*", x, "=", x*y, end="\t\t") 5 print() |
| len |
方法返回對象（字符、列表、元組等）長度或項目個數。 |
|
| complex(real[,imag]) |
創建一個復數，其值為real + imag * j |
|
| dir([object]) |
返回object對象的屬性名稱列表。若沒有指定參數object，則會返回現有的區域符號表（Loaal Symbol Table） |
|
| divmod(a,b) |
將a除以b的商與余數以元組類型返回，若a、b是整數或是長整數，返回值為(a/b,a%b), |
1 >>> divmod(5,3) 2 (1, 2) |
| exal(expression[,globals[,locals]]) |
運行expression表達式。global定義全局命名空間(global namespace),locals定義局部命名空間(locals namespace)。若沒有locals參數，則使用globals定義值。若沒有globals與locals參數，則使用單元本身的命名空間 |
|
| exec string [in globals[,locals]] |
運行包含Python程序代碼的字符串string，globals與locals分別定義全局命名空間與局部命名空間 |
|
| id(object) |
返回object對象的唯一識別碼，此識別碼為一整數 |
1 >>> t = 9 2 >>> id(t) 3 1639045424 |
| int(x[, radix]) |
x為數值/字符串,若是字符串，可以設置radix值。radix是進制的基底值，可以是[2,36]之間的整數或0.若radix是0，則Python會根據字符串值進行判斷。radix是用來說明x是幾進制數 |
1 >>> int(100.5) 2 100 3 >>> int("100",8) 4 64 5 >>> int("100",16) 6 256 7 >>> int("100",0) 8 100 |
| max(s[,args...]) |
若只有一個參數，返回序數對象s中元素的最大值。如果有多個參數，返回最大的序數 |
1 >>> max(1,2,3,5,9) 2 9 3 >>> max("I love you !") 4 'y' 5 >>>max((1,2,3),(2,3),(1,2,4)) 6 (2, 3) |
| min(s[,args...]) |
若只有一個參數，返回序數對象s中元素的最小值。若有多個參數，返回最小的序數 |
1 >>> min(1,2,3,5,9) 2 1 3 >>> min("I love you !") 4 ' ' 5 >>>min((1,2,3),(2,3),(1,2,4)) 6 (1, 2, 3) |
| ord(c) |
返回單字符字符串c的ASCII或Unicode字符。若c是ASCII字符，ord()函數與chr()函數作用相反；若c是Unicode字符，ord()函數與unichr()函數作用相反 |
1 >>> ord("♥") 2 9829 3 >>> chr(9829) 4 '♥' |
| pow(x, y[, z]) |
若沒有參數z返回xy，如果有z，則返回xy % z,y不能是負數 |
1 >>> pow(2,4) 2 16 3 >>> pow(2,4,5) 4 1 5 >>> pow(2,-1) 6 0.5 |
| tuple(sequence) |
使用sequence來創建一個元組對象。若sequence本身就是一個元組，其值不變 |
1 >>> tuple("love") 2 ('l', 'o', 'v', 'e') 3 >>> tuple(['l', 'o', 'v', 'e']) 4 ('l', 'o', 'v', 'e') |
用戶自定義函數
1 # def 自定義函數名（形參1，形參2，…）： 2 # 函數體 3 # （return 返回值） 4 # 參數：1.必須參數2.關鍵字參數3.默認參數
1 # 自定義函數 2 def add(x, y): 3 result = x+y 4 return result 5 6 z1 = add(3, 5) # 必須參數傳值 7 z2 = add(y=5, x=3) # 關鍵字參數傳值 8 print("z1 = ", z1, ",z2 = ", z2) # z1 = 8 ,z2 = 8
__init__.py 文件的使用
1 import src.com.wx.ACM 2 # 歡迎來到IT決戰空間，請展示您的代碼效果了！ 3 # src.com.wx.ACM_file.__init__.py 4 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 5 6 import src.com.wx.PracticeTraining 7 # 歡迎來到IT決戰空間，請展示您的代碼效果了！ 8 # src.com.wx.PracticeTraining_file.__init__.py 9 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 10 11 import init 12 # 歡迎來到IT決戰空間，請展示您的代碼效果了！ 13 # src.com.wx.PracticeTraining.init_file.__init__.py 14 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Python日期和時間
python中時間日期格式化符號
| %y |
兩位數的年份表示（00-99） |
| %Y |
四位數的年份表示（000-9999） |
| %m |
月份（01-12） |
| %d |
月內中的一天（0-31） |
| %H |
24小時制小時數（0-23） |
| %I |
12小時制小時數（01-12） |
| %M |
分鍾數（00=59） |
| %S |
秒（00-59） |
| %a |
本地簡化星期名稱 |
| %A |
本地完整星期名稱 |
| %b |
本地簡化的月份名稱 |
| %B |
本地完整的月份名稱 |
| %c |
本地相應的日期表示和時間表示 |
| %j |
年內的一天（001-366） |
| %p |
本地A.M.或P.M.的等價符 |
| %U |
一年中的星期數（00-53）星期天為星期的開始 |
| %w |
星期（0-6），星期天為星期的開始 |
| %W |
一年中的星期數（00-53）星期一為星期的開始 |
| %x |
本地相應的日期表示 |
| %X |
本地相應的時間表示 |
| %Z |
當前時區的名稱 |
| %% |
%號本身 |
1 import time 2 import calendar 3 def Calendar(): 4 year = int(time.strftime("%Y", time.localtime())) 5 month = int(time.strftime("%m", time.localtime())) 6 cal = calendar.month(year, month) 7 print(cal) 8 Calendar() 9 # July 2019 10 # Mo Tu We Th Fr Sa Su 11 # 1 2 3 4 5 6 7 12 # 8 9 10 11 12 13 14 13 # 15 16 17 18 19 20 21 14 # 22 23 24 25 26 27 28 15 # 29 30 31 16 17 print('北京時間:') 18 print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())) # 獲取當前日期時間 19 # 北京時間: 20 # 2019-07-08 20:17:42
如有錯誤或不足，請留言，謝謝！
本文鏈接：https://www.cnblogs.com/AI-Star-Java/p/11718743.html
謝謝欣賞！關注一下！精彩不斷！