1. 什么是Python?

Python由荷蘭人吉多·范羅蘇姆，于1990 年代初設計

• python是編程語言的一種
• 高級語言又有很多種，比如 C++、Java、C#、PHP、JavaScript 等，Python 也是其中之一
• Python 2于2000年10月16日發布，穩定版本是Python 2.7。
• Python 3于2008年12月3日發布，不完全兼容Python 2。

2. Python - 編寫規范

• 1.縮進做到統一，不建議用tab，不要混用（建議用4個空格來縮進代碼）
• 2.如果一個文本字符串在一行放不下, 可以使用圓括號來實現隱式行連接x = ('這是一個非常長非常長非常長非常長 ' '非常長非常長非常長非常長非常長非常長的字符串')
• 3.不要在逗號, 分號, 冒號前面加空格, 但應該在它們后面加(除了在行尾)
• 4.參數列表, 索引或切片的左括號前不應加空格

3. Python - 算數運算符

運算符|描述|實例
–|–|–|–

• |加 | 10+20=30
  -|減|10-20=-10
  |乘|1020=200
  /| 除|10/20=0.5
  //| 取整| 10//20=0
  %| 取余數|10%20=0
  | 平方計算|23=8

優先級

1、先乘除后加減，同級從左到右，（）優先計算
2、（** 冪） 高于 （ * / % // ） 高于（ + -）

4. Python - 變量介紹

變量類型和命名

分為：數字型和非數字型

1）數字型

• 整數 int
• 浮點型 float （%.2f 保留小數點后兩位）
• 布爾型 bool (True Flase)

2）非數字型

• 字符串 str (注意：字符串和整數不能相加，字符串之間相加 =連接)
• 列表 list
• 元組 tuple
• 字典 dict

變量命名就是通過標識符進行賦值，比如name = ‘xiyu’ ，name就是標識符，xiyu就是賦的值。

一、規則：
1）標識符可以是數字、字母和下劃線組成
2）標識符不能以數字開頭
3）標識符不能以關鍵字命名（關鍵字主要是python內部已經使用的標識符）
4）區分大小寫

二、方式：
1）小駝峰（第一個單詞小寫，后續單詞首字母大寫） mail firstName
2） 大駝峰 （每一個單詞首字母都是大寫） FirstName

案例

mail = 123456789 mailKey = 123456 name = 'xiyu' #如果變量賦值為字符串，需要使用引號print(mail) print(mailKey) print（name）price = 4.5 weight = 7.8 money = price * weight print(money)

5. Python - input函數

案例

price_str = input("請輸入蘋果價格:") price = float(price_str) #默認的字符串轉為浮點型weight_str = input("請輸入重量：") weight = float(weight_str) #默認的字符串轉為浮點型 money = price * weightprint(money)

6. Python - 格式化輸出

格式

%s 字符串
%d 十進制整數
%f 浮點數
%% 輸出%

• 語法 ： print(‘格式化字符串’ % 變量1)
• 語法 ： print(‘格式化字符串’ % （變量1，變量2…)))
• 語法： print(f’格式化字符串{變量1},{變量2}') #f格式化輸出是python3.6新增方法。

案例

name = 'xiaoyu' print('我的名字叫%s,請多多關照' % name)stu_number = 123 print('我的學號是:%d' % stu_number) price = float(input('蘋果的單價是：')) weight = float(input('蘋果的重量為：')) money = price * weight print('蘋果的單價是：%.2f，蘋果的重量是：%.2f，蘋果的總價是：%.2f' %(price, weight, money)) #%.2f代表小數點保留2位，%.3f代表小數點保留3位

7. Python - 條件判斷（if循環）

格式

if 要判斷的條件：條件成立時，要做的事情 else條件不成立時，要做的事情

案例

age = 3 if age >= 3 :print('可以入學幼兒園') else:print('年齡太小，回家玩吧')

案例

age = int(input('請輸入年齡：')) #將默認字符轉為int類型 if age >= 3 :print('可以入學幼兒園') else:print('年齡太小，回家玩吧')

elif

time = int(input('請輸入時間點（1）代表1點，（20）代表20點:')) if time >= 6 and time < 12:print('您輸入的時間是%s點 現在是上午' % time) elif time >= 12 and time <= 12:print('現在是中午') elif time >= 13 and time < 18:print('現在是下午') else:print('現在時間是晚上')

8. Python - 邏輯運算

and

案例

age = int(input('請輸入年齡：')) if age >= 3 and age <=6 :print('可以入學幼兒園') else:print('年齡太合適，回家去吧')

or

age = int(input('請輸入年齡：')) if age <= 5 or age >=22 :print('可以進幼兒園') else:print('年齡太合適，回家去吧')

not

student = True # bool型分為True和False，True代表是學生 if not student:print('請不要進入校園') #取反 else :print('請進入校園')

9. Python - random模塊

案例
在7.4案例的基礎上import導入一個隨機數模塊random，從1-24中隨機取值

import random print(random.randint(1, 24))

10. Python - 條件判斷（while循環）

案例

i = 1 #聲明一個變量 while i <= 5: #關鍵字while 后面跟一個條件print('Hi,同學好')i += 1 #執行打印一次后，給他一個條件 print('循環結束后的值為 %d' % i)

死循環

i = 0 while True:i += 1print('這是一個死循環：%d' % i)

自然計數法：從1開始
程序計數法：從0開始

案例
計算0-100所有數字的和

i = 0 result = 0 while i<= 100:print(i)result += ii += 1 print('所有數字的和為: %d ' % result)

案例
計算0-100所有偶數數字的和

i = 0 result = 0 while i<= 100:print(i)result += ii += 2 print('所有偶數的和為: %d ' % result)

或者

i = 1 result = 0 while i <= 100:if i % 2 ==0:print(i)result += ii += 1else:i += 1 print('所有偶數的和為: %d ' % result)

while循環嵌套

while 條件1：條件滿足時，做的事情1條件滿足時，做的事情1條件滿足時，做的事情1while 條件2：條件滿足時，做的事情1條件滿足時，做的事情1條件滿足時，做的事情1處理條件2處理條件1

9*9乘法表

y = 1 #y 代表行數，最大9行 while y <= 9:x = 1while x <= y:print("%d * %d = %d" %(x, y, x*y),end="\t")x += 1print("")y += 1

11. Python - 終止循環（break和continue）

break

i = 0 while i <= 10: #當i == 5的時候直接中斷，并且不打印，所以只打印到4if i == 5:breakprint(i)i += 1 print("over")

continue

i = 0 while i <= 10:if i == 5: #當i等于5時，它會中斷(意思就是這次不打印了)，但是由于下面的continue，它會繼續，直到i<=10 就會整體中斷i += 1continue #只作用域if循環 而且i == 5的那一次print(i)i += 1 print("over")

12. 列表

List （列表）是python中最頻繁的數據類型，專門用于存儲一串信息

• 列表中[] 定義，數據之間用 , 分隔
• 列表索引從0開始
• 索引就是數據在列表中的位置編號，又被稱為下標

下標除了列表使用到之外，還有列表、元組都會使用到

序號分類函數/方法說明

1	增加-	列表.insert(索引，數據)	在指定位置插入
-	-	列表.append(數據)	末尾插入
-	-	列表.extend(列表2)	將列表2的數據追到的列表
2	修改	列表.[索引]=數據	修改指定索引數據
3	刪除	del列表[索引]	刪除指定索引數據
-	-	列表.remove[數據]	刪除第一個出現的指定數據
-	-	列表.pop	刪除末尾數據
-	-	列表.pop(索引)	刪除指定索引數據
-	-	列表.clear	清空列表
4	統計	len(列表)	列表長度
-	-	列表.count(數據)	數據在列表中出現的次數
5	排序	列表.sort()	升序排序
-	-	列表.sort(reverse=True)	降序排序
-	-	列表.reverse()	逆序 反轉

定義序列

name_list = ["小明", "小夏", "小紅"] #定義列表 print(name_list)

插入

name_list.insert(0, "小亮") #在下標0前面插入數據 name_list.insert(2, "小胡") #在下標2前面插入數據 name_list.append("小末") #末尾添加 print(name_list)

清空列表

name_list.clear() #清空列表 print(name_list)

統計長度

name_list = ["小明", "小夏", "小紅"] print(len(name_list)) #索引計數從0開始，但是統計長度從1開始

統計出現次數

name_list = ["小明", "小夏", "小紅"] name_list.append("小明") print(name_list) print(name_list.count('小明'))

升降序

number_list = [2, 4, 1, 5, 3, 7, 6, 9, 8] print(number_list)number_list.sort() #升序 print(number_list)number_list.sort(reverse=True) #降序 print(number_list)number_list.reverse() #逆序 print(number_list)

循環取值

number_list = [2, 4, 1, 5, 3, 7, 6, 9, 8] for i in number_list:print(i)print(type(i))

列表合并

number_list_1 = [1, 2, 3] number_list_2 = [4, 5, 6, 7] number_list_1.extend(number_list_2) #將列表2追加到列表1中 print(number_list_1)number_list_1 = [1, 2, 3] number_list_3 = ['小虎','小七'] number_list_1.extend(number_list_3) print(number_list_1)

13. 元組

Tuple 元組與列表類似，不同之處 元組的元素不能修改

• 元組 表示多個元素組成的序列
• 元組再python開發中，有特定的應用場景
• 用于存儲一串信息，數據之間使用 ， 分隔
• 元組用（）定義
• 元組的索引從0開始
• 索引就是數據在元組中的位置編號
  info_tuple = (“xiaohu”,22,1.82)

創建空元組

info_data = () print(info_data)

元組中只包含一個元素時，需要在最后加逗號

info_data = (100,) #如果不加逗號，類型為int，非tuple

元組常用操作

count統計元組中出現的元素的次數

info_date_1 = (1, 2, 3, 4, 5, 1, 1) print(info_date_1.count(1)) #d得到的結果就是3，3個1

index 指的是當前元素的下標

info_date_2 = (1, 2, 3, 4, 5, 1, 1) print(info_date_2.index(4)) #從0開始計算，4的下標就是3

循環遍歷

info_date_1 = (1, 2, 3, 4, 5, 1, 1) for i in info_date_1:print(i)print(type(i))

類型轉換

info_date_1 = (1, 2, 3, 4, 5, 1, 1) print(type(info_date_1)) print(type(list(info_date_1))) print(type(tuple(info_date_1)))

14. 字典

dictionary（字典）是除列表以外最靈活的數據類型

• 存儲多個數據 ， 通常描述一個物體的相關信息
• 列表是有序的對象集合，字典是無序的對象集合
• 用 {} 定義
• 使用鍵值對存儲數據，用 , 分隔
  • 鍵 key 是索引
  • 值 value 是數據
  • key value 使用：分隔
  • 鍵值必須唯一
  • 值可以是任何數據類型，鍵只能是 字符串、數字 或者元組

案例

xiaoming = {"name" : "小明","age" : "22","gender" : "True","height" : "1.82"}print(xiaoming) print(type(xiaoming)) #返回是dict類型

查找

xiaoming = {"name" : "小明","age" : "22","gender" : "True","height" : "1.82"}print(xiaoming) print(type(xiaoming)) print(xiaoming['name']) #返回名字 #print(xiaoming.['address']) #因為沒有元素，會報錯 print(xiaoming.get('address')) #使用get不會報錯 返回None print(xiaoming.keys()) #返回key值 print(xiaoming.values()) #返回value值 print(xiaoming.items()) #返回所有的k-v

修改

xiaoming['name'] = 'xiaohong' #將name中的xiaoming改成xiaohong print(xiaoming)

刪除

del xiaoming['gender'] print(xiaoming)

隨機刪除

print(xiaoming.popitem()) print(xiaoming)

循環

for k,v in xiaoming.items():print(k,v)for k in xiaoming:print("%s: %s" % (k, xiaoming[k])) #[k]內部不加引號

其他
xiaoming.clear
xiaoming.items
xiaoming.popitems
xiaoming.setdefault
xiaoming.copy
xiaoming.keys
xiaoming.value
xiaoming.update
xiaoming.fromkeys
xiaoming.pop
xiaoming.get

15. 列表、元組和字典對比

對比表

類型列表元組字典

定義	List （列表）是python中最頻繁的數據類型，專門用于存儲一串信息	與列表類似，不同之處 元組的元素不能修改	dictionary（字典）是除列表以外最靈活的數據類型,存儲多個數據 ， 通常描述一個物體的相關信息
靈活性	最頻繁	不靈活	最靈活
修改	可修改	不可修改	可修改
定義符	[]	()	{}
索引	有	有	有
分隔符	,	,	,
是否有鍵值	無	無	有

16. 字符串

字符串 就是一串字符

• python中可以使用 一對雙引號 或者 單引號 定義
• 可以使用\ " 或者 '進行轉義
  • 如果字符串內部用 ” 可以使用 ’ 定義字符串
  • 如果字符串內部用 ‘ 可以使用 “ 定義字符串
• 可以使用索引獲取一個字符串中的位置，索引從0開始
• 也可以使用for 循環遍歷

定義for循環

str_test= "hello world" #for循環 for s in str_test:print(c)

切片

str_test = "hello world" print(str_test[1]) #切片 print(str_test[1:]) #按照切片取值，從1開始到最后 print(str_test[1:6]) #按照切片取值，從1開始到6

大小寫

str_test = "hello world" #定義string s1 = str_test #定義為s1 print(s1.capitalize()) #用capitalize方法進行開頭大寫 print(s1.title()) #用title方法將每個單詞首字母都大寫 print(s1.upper()) #用upper方法將所有單詞都大寫 str_test_01 = "HELLO world" s2 =str_test_01 print(s2.lower()) #用lower方法將所有單詞都小寫

find 查找

str_test = "hello world" print(str_test.find('or')) #查找內容中or的索引 print(str_test.find('a')) #如果不存在返回 -1

index 查找

str_test = "hello world" print(str_test.index('or')) #查找內容中or的索引 print(str_test.index('a')) #如果不存在返回ValueError: substring not found

find 和 rfind 查找

s = 'hello good world' print(s.find('o')) #從前向后查找 首次o出現的位置，所以索引坐標為4print(s.find('o', 5)) #從前向后查找 從5開始查找o出現的位置,索引坐標為7print(s.rfind('o')) #從后向前查找 首次o出現的位置，所以索引坐標為12

性質判斷

str_test = "hello world!"print(str_test.startswith('He')) #判斷開始否是He開頭，不是則返回Falseprint(str_test.startswith('hel')) #判斷開始否是hel開頭，是則返回Trueprint(str_test.endswith('!')) #判斷末尾否是！結尾，是則返回True

字母、數字構成判斷

str_test_01 = "abcd1234" print(str_test_01.isdigit()) #判讀是否純數字，返回True和False print(str_test_01.isalnum()) #判讀是否是數字和字母構成，返回True和Falsestr_test_02 = "1234" print(str_test_02.isdigit()) #判讀是否純數字，返回True和False print(str_test_02.isalpha()) #判讀是否字母構成，返回True和False

格式化字符串

a = 123 b = 321 print('%d * %d = %d' % (a, b, a * b)) #第一種方式 print('{0} * {1} = {2}'.format(a, b, a * b)) #第二種方式 print(f'{a} * {b} = {a * b}') #第三種方式，python3.6開始在字符串之前用f格式化字符串 #輸出 123 * 321 = 39483 123 * 321 = 39483 123 * 321 = 39483針對f格式化，常用以下方式 print(f'{3.1415926:.3f}') #格式化輸出保留小數點 print(f'{a:.3f}') print(f'{a:0>10d}') #向左補0，補夠10位 print(f'{a:>10d}') #向左補空格，補夠10位 print(f'{a:.2%}') #百分比格式 #輸出 3.142 0000000123123 12300.00%

格式化 - 對齊

str_test = 'hello world' print(str_test.center(20,'*')) #補齊20個字符，不夠用*補齊 print(len(str_test.center(20,'*'))) #查看長度print(str_test.rjust(20)) #右對齊 print(str_test.ljust(20)) #左對齊print('33'.zfill(5)) #字符串左側補0 print('-33'.zfill(5)) #字符串左側補0，負號有算一個字符

字符串修剪

str_test =' aliyun.com \t\n\r ' print(str_test.strip()) #strip方法將左右兩側特殊字符和空格修剪掉 print(str_test.rstrip()) #將右側修剪掉 print(str_test.lstrip()) #將左側修剪掉

替換

str_test ='hello world' print(str_test.replace('o', '@')) #replace方法將o替換成@ print(str_test.replace('o', '@', 1)) #replace方法將第一個o替換成@

合并

str_test = 'i love you' print(str_test) #打印 print(str_test.split()) #拆分后的字符 變成了一個列表 words = str_test.split() #將添加,號之后的內容賦值給words print('#'.join(words)) #將列表用join方法對words進行組合，使用#進行組合 #輸出 i love you ['i', 'love', 'you'] i#love#you

拆分

str_test = 'i#love#you#so#much' #字符串用#連接一起 print(str_test) #打印 words = str_test.split('#') #使用split對#進行拆分 print(words) #打印#輸出 i#love#you#so#much ['i', 'love', 'you', 'so', 'much']

編碼/解碼

python中除了字符串外，還有一種表示二進制數據的字節串類型（bytes），由零個或者多個字節組成的有限序列
1、通過字符串的encode方法，可以按照某種編碼方式將字符串編碼為字節串
2、也可以通過字節串的decode方法，將字節串解碼為字符串

a = '熙雨' #定義a b = a.encode('utf-8') #使用encode對a進行編碼 c = a.encode('GBK') #編碼，大小寫均可 print(b,c)print(b.decode('utf-8')) #解碼，需要用同樣的方法 print(c.decode('gbk')) #解碼

17. 集合

集合是除列表、元組后的另一種數據類型，名字叫集合（set）
- 無序性：一個集合中，每個元素地位相同，元素之間是無序的
- 互異性：一個集合中，不會出現兩個重復的元素
- 確定性：一個集合中，一個元素要么屬于它，要么不屬于它

• 列表和集合間可以相互轉換，set本身有去重功能

創建集合

data_list = {1,2,3,4,5,6,5,4,3,2,1} print(data_list) #輸出 {1, 2, 3, 4, 5, 6} #集合有去重功能data_list = {} #如果定義了一個空值，那么默認是dict字典，除非用set定義 print(type(data_list)) #輸出 <class 'dict'>data_list = set() #如果定義了一個空值，需要用set print(type(data_list)) #輸出 <class 'set'>

循環遍歷

set_list_1 = {num for num in range(1, 20) if num % 3 ==0} #判斷符合條件的數字 print(set_list_1) #打印集合 print(type(set_list_1)) #打印類型 for i in set_list_1: #遍歷 print(i)print(type(i)) #遍歷后類型為int 整數類型

成員運算

成員運算：通過成員運算 in 和not in 檢查元素是否在集合中

set1 = {1, 2, 3, 4, 5, 6} #定義一個集合 print(1 in set1) #如果1 在集合中返回True print(7 in set1) #如果7在集合中返回True，不在就返回False print(7 not in set1) set2 = {'python','c++','java'} #不僅數字，字符也可以 print('python' in set2) print('go' in set2)#輸出 True False True True False

交并差運算

交并差運算：跟數學上集合一樣，可以進行交集 并集 差集進行運算

set1 = {1, 2, 3, 4, 5, 6, 7} set2 = {2, 4, 6, 8, 10}print(set1 & set2) #第一種方式計算交集 print(set1.intersection(set2)) #第二種方式計算交集，結果同上print(set1 | set2) #第一種方式計算并集，由于集合不允許重復，所以重復的不顯示 print(set1.union(set2)) #第二種方式計算并集，由于集合不允許重復，所以重復的不顯示print(set1 - set2) #第一種方法計算差集 print(set1.difference(set2)) #第二種方式計算差集print(set1 ^ set2) #第一種方式計算對稱差 print(set1.symmetric_difference(set2)) #第二種方式計算對稱差 print((set1 | set2) - (set1 & set2)) #第三種方式計算對稱差（并集-交集=對稱差）#輸出 {2, 4, 6} 交集 {2, 4, 6} 交集 {1, 2, 3, 4, 5, 6, 7, 8, 10} 并集 {1, 2, 3, 4, 5, 6, 7, 8, 10} 并集 {1, 3, 5, 7} 差集 {1, 3, 5, 7} 差集 {1, 3, 5, 7, 8, 10} 對稱差 {1, 3, 5, 7, 8, 10} 對稱差 {1, 3, 5, 7, 8, 10} 對稱差

比較運算

兩個集合可以用 == 和 != 進行相等性判斷
1、如果兩個元素完全相同，結果是True，否則False
2、如果集合A的任意一個元素都是集合B的元素，那么A是B的子集，B是A的超集

set1 = {1, 3, 5} set2 = {1, 2, 3, 4, 5} set3 =set2 print(set1, set2, set3)# <運算符表示真子集，<=代表子集 print(set1 < set2) #1為2的真子集 print(set1 > set2) print(set1.issubset(set2)) #通過issubset判斷子集,等同<= print(set1 <= set2) print(set2.issuperset(set1)) #通過issuperset判斷超級，等同> print(set2 > set1) print(set2 <= set3)#輸出 {1, 3, 5} {1, 2, 3, 4, 5} {1, 2, 3, 4, 5} True False True True True True True

集合方法

python中的集合是可變類型，可以通過集合方法為集合添加或者刪除元素

集合方法 - 增加

set1 = set() #定義空集合 set1.add(22) #添加元素 set1.add(33) #添加元素 print(set1)

集合方法 - 更新/添加

set1.update({1, 2, 3, 4, 5}) #更新新增元素 print(set1)

集合方法 - 刪除

set1.discard(1) #如果刪除的元素不存在，也不會報錯，跟remove的區別 print(set1)set1.remove(2) #如果刪除的元素不存在，會報錯，建議使用if判斷刪除，就算不存在也不會報錯 print(set1) if 3 in set1:set1.remove(3) print(set1)print(set1.pop()) #使用pop方法隨機刪除一個元素并返回這個元素 print(set1.clear()) #全部清空，返回None#輸出 {33, 22} {33, 1, 2, 3, 4, 22, 5} {33, 2, 3, 4, 22, 5} {33, 3, 4, 22, 5} {33, 4, 22, 5} 33 None

集合方法 - 判斷相同

#判斷兩個集合有沒有相同元素，可以使用isdisjoint方法，沒有的話返回True,否則返回False set1 = {'java','python','go','c++'} set2 = {'c++','c','css','html'} print(set1.isdisjoint(set2)) #因為1和2中有相同的c++元素，因此返回False#輸出 False

不可變集合

python中還有一種不可變類型的集合，叫frozenset，set跟frozenset的區別就如同list和tuple一樣，frozenset由于是不可變類型，能夠計算出哈希碼，因此它可以作為set中的元素。除了不能添加和刪除原酸，frozenset在其他方面與set基本一樣

set1 = frozenset({1, 3, 5, 7}) #定義set1 set2 = frozenset(range(1, 6)) #定義set2 print(set1, set2) print(set1 | set2) #并集 print(set2 & set2) #交集 print(set1 - set2) #差集 print(set1 < set2) #子集#輸出 frozenset({1, 3, 5, 7}) frozenset({1, 2, 3, 4, 5}) frozenset({1, 2, 3, 4, 5, 7}) frozenset({1, 2, 3, 4, 5}) frozenset({7}) False

python的集合底層使用了哈希存儲的方式，具體原理不做介紹，現階段了解集合是一種容器，元素必須是hashable類型就好，與列表不同的地方在于集合中元素沒有序，不能用索引運算，不能重復。

18. 函數

18.1 函數的基本使用

什么是函數？

把具有獨立功能的代碼塊，組織為一個小模塊，在需要的時候進行調用

函數格式

def 函數名():函數封裝的代碼...

1、def是英文define的縮寫
2、函數名應該能夠表達函數封裝代碼的功能，方便后續調用
3、函數名稱的命名應該符合標識符的命名規則

• 可以由字母、數字、下劃線組成
• 不能以數字開頭

18.2 函數的調用

#定義函數 """ 說明：此處是對函數添加注釋，定義函數的作用和目的 """ def weekend():print("it's a nice day today")print('I want to go out') #調用函數 weekend() 注意：函數調用必須放在定義函數之后

PyCharm調試工具


注意：鼠標左鍵點中左側后，出現紅點，然后進行debug，可以查看單步執行結果。

函數注釋

在 定義函數 下方，使用連續的三對引號（上圖所示），在引號內編寫對函數的說明文字，然后在 函數調用 位置使用Ctrl+Q 可以查看函數的說明信息

18.3 函數傳遞參數

函數參數：增加函數的通用性，針對相同的數據處理邏輯，能夠使用更多的數據，在函數內部，把參數當作變量使用，函數調用時，按照函數定義的“參數順序”，把希望在函數內部處理的數據，通過參數傳遞

• 固定參數

def sum_num():num1 = 10 #寫入兩個固定值num2 = 20result = num1 + num2print('%d + %d = %d' % (num1, num2, result)) sum_num() print(type(sum_num())) 如果才行隨意傳入兩個值，進行計算？？這就用到了函數參數。

• 傳遞參數

def sum_num_s(num1, num2): #定義兩個參數 num1和num2result = num1 + num2print('%d + %d = %d' % (num1,num2,result)) sum_num_s(5, 6) #在此處傳入兩個參數5和6

18.4 函數的返回值

返回值：一個函數執行后，告訴調用者一個結果，使用return關鍵字進行返回結果，也可以使用變量來接收函數的返回結果

def sum_num(num1, num2):return num1 + num2print('這是一個測試') #return后面的代碼不會被執行，因此結果沒有該信息#我們可以使用一個變量進行函數的返回值的接收 result = sum_num(20, 30) print('計算結果：%d' % result)#輸出 計算結果：50

注意：在函數中使用return，return后面的代碼就不會被執行的。return代表當前函數已經執行完畢，若是要打印兩個值，需要傳遞兩個變量

def sum_num(num1, num2):return num1, num2print('這是一個測試') #return后面的代碼不會被執行，因此結果沒有該信息#我們可以使用一個變量進行函數的返回值的接收 result = sum_num(20, 30) print(f'輸出的值分別為:{result}')#輸出 (10, 20)

18.5 函數嵌套

嵌套調用：一個函數里面又被另外一個函數調用，就是函數嵌套
如果函數 test2 中，調用了另外一個函數 test1

• 那么執行調用時，先執行完test1，再回到test2中繼續執行后續代碼

def test1():print('*' * 50)print('當前函數名稱：test1')print('*' * 50)def test2():print('-' * 50)print('當前函數名稱：test2')test1() #在此調用函數test1print('-' * 50)test2() #調用test2#輸出 -------------------------------------------------- 當前函數名稱：test2 ************************************************** 當前函數名稱：test1 ************************************************** -------------------------------------------------- Process finished with exit code 0

案例

def print_line_1(char): #用參數定義分割線print(char * 50) #傳入分割線和次數 print_line_1('_') #將分割線定義為 - 符號，并調用 def print_line_2(char, num): #用參數定義分割線和次數print(char * num) print_line_2('%',10) #將分割線定義為 % 符號和次數，并調用 def print_line_3(char, num): #先定義一個函數，和參數print(char * num)def print_line_4(char, num): #再定義函數和參數row = 0 #定義行數初始為0行while row < 5: #條件print_line_3(char, num)row += 1 #+1 進入循環，如果沒有這個即使死循環 print_line_4('*', 30) #傳入參數給4和3#輸出 __________________________________________________ %%%%%%%%%% ****************************** ****************************** ****************************** ****************************** ******************************Process finished with exit code 0

18.6 模塊中的函數

模塊是Python程序架構的一個核心概念

• 模塊 類似工具包，若要使用這個工具，需要使用 import 進行導入這個模塊
• 每個以擴展名.py結尾的Python源代碼都是一個 模塊
• 在模塊中定義的全局變量、函數 都是模塊能夠提供給外界直接使用的工具

體驗自建模塊
1）定義一個<python自建模塊1.py> ，內容如下：(模塊一定是py結尾，不然import識別不到)

name = "小明"

2）定義一個<python自建模塊2.py> ，內容如下：

def test(num1, num2):print('%d + %d = %d' % (num1, num2, num1 + num2))

3）定義一個<python自建模塊測試> ，內容如下：

import python自建模塊1 #由于python自建模塊與當然腳本同一個目錄，可以直接通過名稱調用 import python自建模塊1print(python自建模塊1.name)python自建模塊2.test(2, 3)#輸出 C:\Users\qingchen\AppData\Local\Programs\Python\Python39\python.exe C:/python_project/Python自建模塊測試.py 小明 2 + 3 = 5Process finished with exit code 0

18.7 函數中的位置參數（含不定長參數）

- 位置參數

def user_info(name, age, gender):print(f'你的名字：{name},你的年齡{age}, 你的性別是{gender}')user_info('細雨', 20, '男') user_info('細雨', '男', 20) #不會報錯，但是位置參數不能調換位置 user_info('細雨', 20) #報錯，位置參數必須數量與函數中一致

- 不定長位置參數=包裹位置傳遞 ，對參數個數沒有限制，返回是元組

def user_info(*args):print(args)user_info('TOM') user_info('TOM', 18)#輸出 ('TOM',) ('TOM', 18)

18.8 函數中的關鍵字參數（含不定長參數）

- 關鍵字參數

def user_info(name, age, gender):print(f'你的名字：{name},你的年齡{age}, 你的性別是{gender}')user_info('細雨', age=20, gender='男') user_info('細雨', gender='男', age=20) #不會報錯，如果函數調用時，如果有位置參數，位置參數（name）一定要在關鍵字參數的前面，關鍵字參數之間不存在先后順序

- 不定長關鍵字參數=包裹關鍵字傳遞，返回是字典

def user_info(**kwargs):print(kwargs)user_info(name = 'TOM', age=20)#輸出 {'name': 'TOM', 'age': 20}

無論是包裹位置傳遞還是包裹關鍵字傳遞，都是一個組包的過程

18.9 函數的運用案例 - 學員管理系統

def info_print():print('1.添加學員')print('2.刪除學員')print('3.修改學員')print('4.查詢學員')print('5.顯示所有學員')print('6.退出系統')info_print() info = []def add_info():"""添加學員函數"""#接收用戶輸入信息new_id = int(input('請輸入學員學號:'))new_name = str(input('請輸入學員姓名:'))new_tel = int(input('請輸入學員手機號:'))global infofor i in info:if new_name == i['name']:print('該學員已經存在')returninfo_dict = {}info_dict['id'] = new_idinfo_dict['name'] = new_nameinfo_dict['tel'] = new_telinfo.append(info_dict)print(info)def del_info():print(f'目前學員信息如下:{info},請按照以下提示進行操作')del_name = input('請輸入要刪除的學員姓名：')#global info#判斷學員是否存在for i in info:if del_name == i['name']:info.remove(i)print(f'學員{del_name}已刪除')breakelse:print('該學員不存在')def modify_info():"""修改學員信息"""modify_name = input('請輸入修改的學員姓名:')global infofor i in info:if modify_name == i['name']:i['tel'] = input('請輸入該學員新的手機號碼:')breakelse:print('該學員不存在') def search_info():"""查詢學員信息"""search_name = input('請輸入要查詢的學員姓名:')global infofor i in info:if search_name == i['name']:print('查找結果如下：')print(f"該學員學號為:{i['id']},姓名是:{i['name']}，手機號為:{i['tel']}")breakelse:print('該學員不存在')def print_all():"""顯示所有學員信息"""print('學號\t姓名\t手機號')for i in info:print(f"{i['id']}\t{i['name']}\t{i['tel']}")def exit_sys():sure = input('確定要退出系統嗎？ 請輸入yes or no:')if sure == 'yes':print('系統已退出！！')elif sure == 'no':info_print()user_num = int(input('請輸入功能序號：')) #循環顯示 while True:user_num = int(input('請輸入功能序號：'))if user_num == 1:print('添加學員，請按照以下說明進行填寫！！')# 調用添加函數add_info()elif user_num == 2:print('刪除學員信息')del_info()elif user_num == 3:print('修改學員信息')modify_info()elif user_num == 4:print('查詢')search_info()elif user_num == 5:print('顯示所有學員')print_all()elif user_num == 6:sure = input('確定要退出系統嗎？ 請輸入yes or no:')if sure == 'yes':print('系統已退出！！')breakelif sure == 'no':info_print()else :print('輸入的序號有誤,請輸入1-6')

19. 面向對象

面向對象是一種非常流行的*編程范式*

19.1 類和對象

#class Student: #用class定義類，Student是類名 class Student(): #同方法 class Student: 此時定義類名使用大駝峰命名法# 如果函數在類中，那么就被稱為類方法def ball(self, course_name): #ball類方法print('學生正在操場打：%s.' % course_name)def read(self, book): #read也是一個方法print(f'學生們正在看：{book}.')stu01 = Student() #定義類Student的對象為stu01 print(stu01) #直接打印對象的話，會輸出的值為實例在內存中的地址（16進制） print(id(stu01)) #打印當然對象的id print(hex(id(stu01))) #將id轉為16進制 ，用hex公共方法#使用對象調用方法，打印結果 stu01.read('小說')#想要去調用當前類中的方法，先要對類進行實例化，實例化方法就是對類Student() Student().ball('basketbook 籃球')#輸出 C:\Users\qingchen\AppData\Local\Programs\Python\Python39\python.exe "C:/python_project/面向對象 - 類和對象.py" <__main__.Student object at 0x000001F076BE3FD0> 2132295958480 0x1f076be3fd0 學生們正在看：小說. 學生正在操場打：basketbook 籃球.Process finished with exit code 0

注意：

用class定義一個類（比如Student），類里面的函數成為類方法

通過類聲明一個對象（stu01）

通過對象.方法去調用類中的方法

通過類().方法去調用類中的方法 //類（）就是對類進行實例化，之后才能調用

19.2 初始化方法

之前我們創建的對象只有行為，沒有屬性，如果要給對象定義屬性，可以使用一個名為__init__的方法。

在我們調用Student類的構造器創建對象時，首先會在內存中獲得保存學生對象所需的內存空間，然后通過自動執行__init__方法，完成對內存的初始化，也就是把數據放到內存空間中，所以我們可以通過給Student類添加__init__方法的方式為學生對象指定屬性，同時完成對屬性賦初始值的操作，因此，__init__方法也被稱為初始化方法。

class Student:#初始化方法 給當前對象創建屬性def __init__(self, name, age):#給當前類添加屬性self.name = nameself.age = agedef ball(self, course_name): # ball 為類方法print('學生%s正在操場打%s' % (self.name, course_name)) #普通輸出，不用f格式化print(f'學生{self.name}正在操場打{course_name}') #f格式化輸出def read(self, book): # read也是一個方法print(f'學生{self.name}正在看{book}.')#實例化類 stu01 = Student('熙雨',22) stu01.ball('籃球')stu02 = Student('小野',21) stu02.read('挪威的森林')#輸出 學生熙雨正在操場打籃球 學生熙雨正在操場打籃球 學生小野正在看挪威的森林.Process finished with exit code 0

19.3 打印對象

打印對象的結果時一串內存地址，但是我們不想看到這些，做到自定義就可以用到repr魔法方法

class Student:#初始化方法 給當前對象創建屬性def __init__(self, name, age):#給當前類添加屬性self.name = nameself.age = agedef __repr__(self):return (f'這個地方如果不用repr魔法方法的話,默認打印時內存地址')def ball(self, course_name): # ball 為類方法 # print('學生%s正在操場打%s' % (self.name, course_name)) #普通輸出，不用f格式化print(f'學生{self.name}正在操場打{course_name}') #f格式化輸出def read(self, book): # read也是一個方法print(f'學生{self.name}正在看{book}.')#實例化類 stu01 = Student('熙雨',22) stu01.ball('籃球') print(stu01)stu02 = Student('小野',21) stu02.read('挪威的森林')#輸出 學生熙雨正在操場打籃球 這個地方如果不用repr魔法方法的話,默認打印時內存地址 學生小野正在看挪威的森林.

19.4 可見性與屬性裝飾器

class Student():#初始化方法 給當前對象創建屬性def __init__(self, name, age):#給當前類添加屬性self.__name = nameself.__age = agedef __repr__(self):return (f'這個地方如果不用repr魔法方法的話,默認打印時內存地址')def ball(self, course_name): # ball 為類方法 # print('學生%s正在操場打%s' % (self.name, course_name)) #普通輸出，不用f格式化print(f'學生{self.__name}正在操場打{course_name}') #f格式化輸出def read(self, book): # read也是一個方法print(f'學生{self.__name}正在看{book}.')#實例化類 stu01 = Student('熙雨',22) stu01.ball('籃球')stu02 = Student('小野',21) stu02.read('挪威的森林')print(stu01.name) #print(stu01._Student__name)#輸出 學生熙雨正在操場打籃球 學生小野正在看挪威的森林. Traceback (most recent call last):File "C:\python_project\面向對象-初始化方法.py", line 25, in <module>print(stu01.name) AttributeError: 'Student' object has no attribute 'name'Process finished with exit code 1

說明：如果name加了__就會變成私有屬性，只能在類內部被調用，因此print(stu01.name)會報錯，不過嚴格意義上python并沒有屬性的私密性， 也有方法可以調成功，將外部調用print(stu01.name) 改為print(stu01._Student__name)就可以解決

20. 面向對象-繼承

單繼承和多繼承
面向對象三大特性

• 封裝
• 繼承
• 多態

20.1 面向對象 - 單繼承

概念：子類擁有父類的所有方法和屬性

1、不使用繼承

''' 開發兩個類動物類（特性：吃、喝、跑、睡）狗 （特性：吃、喝、跑、睡、汪汪叫）'''class Animal:def eat(self):print('吃')def drink(self):print('喝')def run(self):print('跑')def sleep(self):print('睡')class Dog:def eat(self):print('吃')def drink(self):print('喝')def run(self):print('跑')def bark(self):print('汪汪叫')#創建對象 wangcai = Animal() wangcai.eat() wangcai.sleep()#創建對象 wangcai = Dog() wangcai.bark()#在不使用繼承的情況下，會造成代碼的重復

1、使用繼承

class 類名(父類名):pass #Python pass是空語句，是為了保持程序結構的完整性。pass不做任何事情，一般用做占位語句。 class Animal:def eat(self):print('吃')def drink(self):print('喝')def run(self):print('跑')def sleep(self):print('睡')class Dog(Animal):def bark(self):print('汪汪叫')class yuque(Dog):def fly(self):print('飛')#創建對象 wangcai = Dog() wangcai.eat() wangcai.bark()#使用繼承的情況下，Dog類可以使用Animal類的方法，調整父類的化，子類的方法也會跟著改變

總結：

• 1、繼承的說明
  子類繼承自父類，可以直接享受父類已經封裝好的方法，不需要再次開發
  子類中應該根據職責，封裝子類特有的屬性和方法

• 2、專業術語
  Dog為Animal的子類（或者叫派生類）
  Animal為Dog的父類

20.2 繼承的傳遞性

C類從B類繼承，B類又從A類繼承
那么C類就具有B和A類的所有屬性和方法

1）案例：動物類 --> 狗類 --> 哮天犬

class Animal:def eat(self):print('吃--')def drink(self):print('喝--')def run(self):print('跑--')def sleep(self):print('睡--')#創建狗類 class Dog(Animal):def bark(self):print('我是狗子，我會汪汪叫') #創建一個哮天犬類 class XiaoTianQuan(Dog):def fly(self):print('我是哮天犬，我會飛')#創建一個哮天犬對象 xtq = XiaoTianQuan() xtq.fly() xtq.bark()#我們可不可以調用Animal中的方法？？？結果證明也是可以的，這就是繼承的傳遞性 xtq.eat() xtq.run() #說明：哮天犬類繼承狗類，夠累繼承動物類，那么哮天犬是狗類的子類，狗類是動物類的子類，那么哮天犬是動物類的子子類#輸出 我是哮天犬，我會飛 我是狗子，我會汪汪叫 吃-- 跑--

注意：在Animal的左側也可以看到有兩個子類

2） 繼承傳遞性的注意事項

class Animal:def eat(self):print('吃--')def drink(self):print('喝--')def run(self):print('跑--')def sleep(self):print('睡--')#創建狗類 class Dog(Animal):def bark(self):print('我是狗子，我會汪汪叫') #創建一個哮天犬類 class XiaoTianQuan(Dog):def fly(self):print('我是哮天犬，我會飛') class Cat(Animal):def catch(self):print('我是貓，我會抓老鼠') #貓類繼承自動物類，自身實現了一個方法（抓老鼠）#創建一個哮天犬對象，現在通過哮天犬對象能不能調用貓類方法？ xtq = XiaoTianQuan() xtq.fly() xtq.bark() xtq.eat()xtq.catch() #會報錯，哮天犬調用貓類方法失敗

注意： 結果證明子類無法繼承父類中其他子類中的方法

20.3 繼承方法的重寫

當父類的方法實現不能滿足子類需求時，可以對方法進行重寫（override），方法就是在子類中定義一個和父類中一個的方法，在子類進行調用時，會調用子類中的方法

class Animal:def eat(self):print('吃--')def drink(self):print('喝--')#創建狗類 class Dog(Animal):def bark(self):print('我是狗子，我會汪汪叫') #創建一個哮天犬類 class XiaoTianQuan(Dog):def fly(self):print('我是哮天犬，我會飛')def bark(self):print('我是哮天犬，叫法肯定跟狗不一樣')#創建一個哮天犬對象,修改哮天犬的繼承Dog的bark方法，讓它不是汪汪叫，因此需要重寫父類方法 xtq = XiaoTianQuan() xtq.bark()#輸出 我是哮天犬，叫法肯定跟狗不一樣 Process finished with exit code 0

20.4 面向對象 - 父類方法調用和拓展

如果子類向調用父類中的方法，需要使用到super()對象

class Animal:def eat(self):print('吃--')def drink(self):print('喝--')#創建狗類 class Dog(Animal):def bark(self):print('我是狗子，我會汪汪叫') #創建一個哮天犬類 class XiaoTianQuan(Dog):def fly(self):print('我是哮天犬，我會飛')def bark(self):print('我是哮天犬，叫法肯定跟狗不一樣') #當子類的方法與父類的方法相同時，如果想調用父類的方法，就要使用super方法super().bark() #super()也是一個對象Dog.bark(self) #或者使用另外一種調用方式，python3中被保留，父類.方法（self）的方式print('這是一個測試...') #輸出 我是哮天犬，叫法肯定跟狗不一樣 我是狗子，我會汪汪叫 我是狗子，我會汪汪叫 這是一個測試...

20.5 面向對象 - 父類的私有屬性和私有方法

`子類對象 不能 在子集的方法內部，直接訪問父類的私有屬性或者私有方法
子類對象 可以通過 父類 的 公有方法 間接 訪問到私有屬性 或者私有方法

• 私有屬性、方法 時對象的隱私，不對外公開，外界以及子類都不能直接訪問
• 私有屬性、方法通常用于做一些內部的事情

案例一、子類無法調用父類的私有屬性

class A:#創建類屬性def __init__(self): #初始化方法#創建公有屬性self.num_1 = 100#創建私有屬性self.__num_2 =200 #當前屬性名稱前面加上__就是私有屬性#創建私有方法def __test(self):print(f'私有屬性與公有屬性的值：{self.num_1},{self.__num_2}')#創建的新類要繼承自類A class B(A):pass #Python pass是空語句，是為了保持程序結構的完整性。pass不做任何事情，一般用做占位語句。#B具有父類A的所有屬性 b = B() print(b.num_1) #打印公有屬性，正常返回 print(b.__num_2) #直接打印私有屬性會報錯#輸出 AttributeError: 'B' object has no attribute '__num_2' 100

案例二、子類無法調用父類的私有方法

class A:#創建類屬性def __init__(self): #初始化方法#創建公有屬性self.num_1 = 100#創建私有屬性self.__num_2 =200 #當前屬性名稱前面加上__就是私有屬性#創建私有方法def __test(self):print(f'私有屬性與公有屬性的值：{self.num_1},{self.__num_2}')#創建的新類要繼承自類A class B(A):# pass #Python pass是空語句，是為了保持程序結構的完整性。pass不做任何事情，一般用做占位語句。def demo(self):#父類方法super.__test()#B調用父類中的私有方法b.demo() #不允許子類直接調用父類的私有方法#輸出IndentationError: unindent does not match any outer indentation level

案例三、子類間接使用父類的私有屬性和私有方法

說明：子類可以通過父類中的公有方法間接訪問到私有屬性和私有方法

class A:#創建類屬性def __init__(self): #初始化方法#創建公有屬性self.num_1 = 100#創建私有屬性self.__num_2 =200 #當前屬性名稱前面加上__就是私有屬性#創建私有方法def __test(self):print(f'私有屬性與公有屬性的值：{self.num_1},{self.__num_2}')def test(self):print(f'父類中的公有方法輸出私有屬性：{self.__num_2}')#在公有方法中調用私有方法self.__test() #可調用成功#創建的新類要繼承自類A class B(A):#公有方法def demo(self):#1.在子類方法中訪問父類的公有屬性print(f'子類方法輸出父類中的公有屬性：{self.num_1}') #可以正常輸出公有屬性#2.在子類中調用父類的公有方法輸出私有屬性self.test() b = B() b.demo()#總結：子類可以通過父類中的公有方法間接訪問到私有屬性和私有方法 #輸出 父類中的公有方法輸出私有屬性：200 私有屬性與公有屬性的值：100,200

20.6 面向對象 - 多繼承

子類 可以擁有多個父類，并且具有所有父類的屬性和方法

class 子類名(父類名1，父類名2...)pass

案例一、子類調用多個父類方法

class A():def test(self):print('test方法')class B():def demo(self):print('demo方法')class C(A, B):passc = C() c.test() c.demo()#總結：在python中，面向對象是支持多個類進行繼承的，子類同時具體多個父類的所有方法和屬性 #輸出 test方法 demo方法

多繼承的使用注意事項
注意：如果在多繼承情況下，父類中的方法有重名，盡量避免使用多繼承，結果會按照調用順序進行繼承

class A():def test(self):print('A --- test方法')def demo(self):print('A --- demo方法')class B():def test(self):print('B --- test方法')def demo(self):print('B --- demo方法')class C(B, A): #注意：調用的順序和繼承的順序一致passc = C() c.test() c.demo() #輸出 B --- test方法 B --- demo方法

20.7 面向對象 - 新式類、舊式類和__mro搜索順序

object 是python為所有對象提供的基類，提供一些內置的屬性和方法，可以使用dir()函數查看

• 新式類：以object為基類的類，推薦使用（python3中默認使用object作為類的基類，而python2中需要手動指定）
• 經典類：不以object為基類的類，不推薦使用

class 類名(object):pass

20.8 面向對象 - 多態

我們在調用子類中的同名方法時，輸出的值不一樣， 包括繼承和重寫

案例 多態

class A():def work(self):print('人類需要工作') class B(A):def work(self):print('程序員在工作 -- 代碼') class C(A):def work(self):print('設計師在工作 -- 圖紙')b = B() c = C() b.work() c.work() #輸出 程序員在工作 -- 代碼 設計師在工作 -- 圖紙

案例 多態演示

class Dog:#定義類屬性def __init__(self, name):self.name = name#定義類的方法def game(self):print('%s 蹦蹦跳跳的玩耍...' % self.name)class XiaoTianQuan(Dog):'''子類繼承父類的時候，具有父類所有的屬性和方法'''#定義類方法def game(self):print(f'{self.name}飛到天上去玩耍...')class Person():#定義類屬性def __init__(self, name):self.name = namedef game_with_dog(self, dog):#讓狗玩耍dog.game()#讓狗與人一起玩耍print(f'{dog.name}是一只狗')print('%s 和%s 快樂的玩耍' % (self.name, dog.name))#創建一個普通狗對象 #wangcai = Dog('旺財') wangcai = XiaoTianQuan('飛天旺財')#創建人的對象 xiaoming = Person('小明') xiaoming.game_with_dog(wangcai) #輸出 飛天旺財飛到天上去玩耍... 飛天旺財是一只狗 小明 和飛天旺財 快樂的玩耍

21. 模塊管理

21.1 模塊查看

查看已安裝模塊，Windows或Linux控制臺下查看模塊

pip list #該命令查看的是Python安裝的第三方模塊。pip freeze #該命令屬于老版本的Python了。pydoc modules #該命令查看的是所有的模塊，包括內建模塊，截圖類似下面的help。

查看已安裝模塊，Python交互解釋器查看模塊

help('modules') #該命令查看的是所有的模塊，包括內建模塊。

查看已安裝模塊，導入sys模塊查看

1 >>> import sys 2 >>> sys.modules.keys() #這個方法查看的更加詳細，只是不太便于觀看。

21.2 模塊安裝

以pymysql為例

pip install pymysql

22 python常用模塊使用

22.1 os模塊

os 模塊提供了豐富的方法用來處理文件和目錄

#導入os模塊 import osos.rename('1.txt', '2.txt') #對文件或者文件夾重命名 os.remove('2.txt') #刪除文件 os.mkdir('xiyu') #創建文件夾 os.rmdir('xiyu') #刪除文件夾 print(os.getcwd('xiyu')) #獲取當前目錄 print(os.chdir(目錄)) #改變路徑 print(os.listdir()) #獲取目錄列表os.getcwd() #獲取路徑 os.chdir() #切換工作目錄到指定的路徑下，如果成功，返回True，操作失敗，返回False os.makedirs(name, mode=511, exist_ok=False) #遞歸地創建目錄并設置訪問權限，類似于linux中的 mkdir -p。默認的訪問權限為 511 os.chmod(path, mode) #更改目錄或文件的訪問權限。os.open(file, flags, mode=0o777) #打開一個文件，并設置打開選項與訪問權限，返回文件對應的描述符。默認的訪問權限為777。os.system(command) #在子shell中執行命令，并返回命令執行的退出狀態碼 os.symlink(src, dst) #為文件 src 創建軟鏈接 dstprint(os.environ) #返回包含當前系統所有環境變量的一個mapping對象

22.2 sys模塊

22.3 time模塊

print(time.clock()) print(time.time()) print(time.localtime()) print(time.strftime("%Y-%m-%d %X",time.localtime()))#輸出 0.02 1648893130.4114902 time.struct_time(tm_year=2022, tm_mon=4, tm_mday=2, tm_hour=17, tm_min=52, tm_sec=10, tm_wday=5, tm_yday=92, tm_isdst=0) 2022-04-02 17:52:10

22.3 pymysql模塊

詳見《24.使用python提取mysql數據庫信息》

24. 使用python提取mysql數據庫信息

#!/usr/bin/python # -*- coding: UTF-8 -*-import pymysqldb = pymysql.connect(host = '47.98.187.230',port = 3306, user = 'root',passwd = 'Admin123****',db = 'myemployees') #使用 cursor() 方法創建一個游標對象 cursor cursor = db.cursor()# 使用 execute() 方法執行 SQL 查詢 #cursor.execute('select * from jobs limit 10') cursor.execute("insert into jobs values ('AC_ACCOUNN', 'Public Accountant', 12000, 20000);") 插入數據，若是insert內部使用單引號，外部必須使用雙引號 cursor.execute('select * from jobs limit 10') #使用 fetchone() 方法獲取單條數據 date = cursor.fetchall()# 使用 execute() 方法執行 SQL 查詢 cursor.execute('SELECT VERSION()') #使用 fetchone() 方法獲取版本號 ver = cursor.fetchall()print(f'數據庫返回記錄為：{date}') print(f'數據庫版本為：{ver}')#關閉數據庫 cursor.close() db.close()

總結

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

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