python自动计算多个教学班的优秀率_第二个月课堂009python之总结(002)
python7天的總結
------------------------------------------------------------------------------------------------
評價：1、函數 def? 自定義行數和內建函數
2、re模塊
3、python3和python的去別
4、字典，元組，列表，元組，集合的聯系和區別
Python
一、Python介紹：
1、什么是Python？
Python是一門面向對象，解釋型的動態類型的編程語言；
Guido van Rossunm?吉多·范羅蘇姆 荷蘭計算機程序員
2、什么是面向對象？
Python中一切皆為對象，對事物的描述和方法系統的定義為一個類，在這個類中的具體的一個實例就是我們所說的對象
例如：人就是一個類? ?-------??wf?對象
3、什么是解釋型？
Python程序執行時無需先進行編譯成二進制代碼，直接在執行過程中對語句一條條進行編譯
例如：java??裝了jdk?編譯，python不需要，可以直接編譯
4、什么是動態類型？
是指Python程序在運行時可以改變其結構，新的函數可以被引進，已有函數可以被刪除
例如：在運行的情況下修改，返回值(存儲過程中可以運行以后拿到值，進行運用)
5、Python的特點？
a.特點：簡單、易學、免費開源、可擴展性、可移植、高級語言、豐富的類庫;
b.應用領域：網頁開發、可視化界面開發、系統編程、數據分析、網絡爬蟲(用的多)、自動化腳本開發(測試用的多)；?java，ruby?、數據分析、AI人工智能、大數據、云計算、
6、Python的實際應用：
Youtube、豆瓣網、知乎
7、Python所支持的平臺：
windows、linux ,macos
8、Python市面上使用的版本：
Python 2.7.xxxx (現在一些windows都支持,穩定)
Python 3.0.xxxx?現在的主流會越來越流行(目前最新版本3.9)；
差別：版本的高低級而已，就是有一些功能不一樣
二、Python中的運算
1，算術運算符
1，+?加；2，-?減；3，*?乘；4，/?除；5，%?取模；6，**取冪
7，//取整除'''
注意點：他們的優先級：先乘除后加減
2，賦值運算
1，+=??加法賦值?；2，-=? ?減法賦值；3，*=?乘法賦值
4，/=??除法賦值；5，%=??取模賦值；6，**=??冪賦值運算符
3，比較運算符
1，== ?等于；2，!=??不等于；3，>??大于；4，
5，>=?大于等于；6，<=??小于等于
注意：結果事返回布爾值：falsh?，true
4，邏輯運算符
1，and?與；2，or?；3，或；4，not? ?非
返回的結果也是布爾值；
5，位運算
1，&按位與
概念：把十進制轉化換二進制，上下對應位都是1，則取1，否則取0，結果再轉化換十進制
2，按位或
把十進制轉換成二進制，上下對應位只要有一個是1，則取1，都為0則取0，結果再轉換十進制|
3，按位異^
把十進制轉換成二進制，上下對應位不相同，取1，相同取0，結果再轉換成十進制
4，?按位取反~
公式?-(a+1)?變量a先加1再取負數
5，?向左移?<<
把變量轉換成二進制，左移相應的位數把小數點右移小數位數，結果是小數點左邊的二進制轉換成十進制
6，?向右移?>>
把變量轉換成二進制，右移兩位把小數點左移兩位，結果是小數點左邊的二進制轉換成十進制
7，成員運算符：in和not in
返回的也是布爾值；
三、?索引與切片
索引：索引?在公司中一般也叫做下標或者角標
1、我們可以通過索引位讀取序列中的指定元素，索引可分為正向索引和負向索引
2、索引的表達式：str[x]?其中x是需要我們自己填寫的一個數據，
如：str[1]、str[0]
3、索引中正向索引從0開始，負向索引從-1開始
4、表示不隔位
[起始索引位:結束位:步長值]
切片語法中：包含起始不包含結束，隔位不能為0可以為1，1表示不隔位,從2開始有效果
遍歷函數中：包含起始不包含結束，隔位不能為0可以為
print (list(range(10)))
打印的結果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2，切片：
1、切片的表達式：str[start_index:end_index:step]?即[開始索引:結束索引:步長值]
2、解釋：start_index：開始索引(可以取值)
end_index：結束索引(不能取值)
step：步長 (腳跨了幾個樓梯)
3、注意
1)切片中如果步長不寫則默認為1
2)切片取值從開始索引到結束索引，且結果不包括結束索引位的值 (取到索引位的前一位)
3)步長從開始索引走起，步長分正負
四、函數
1，字符串函數
capitalize():首字符大寫
count():統計具體字符的個數
join():把字符串中的字符按自定義的分隔符連接在一起
split():把字符串通過制定標識符進行分割
strip(ab):刪除字符串開頭和結尾有a或者b的字符
istrip(ab):刪除字符串開頭有ab序列的字符
rstrip(ab):刪除字符串結尾有ab序列的字符
startswith():判斷字符串是否以什么開始
endswith():判斷字符串是否以什么結尾
find/rfind():查詢指定字符串的下標
replace(substring,newstring,max):替換字符
lower():方法轉換字符串所有大寫字符為小寫字符
upper():字符串中的小寫轉換為大寫
isdigit():判斷字符串中是否全為數字
isalpha():判斷字符串中是否全為字母
isalnum():判斷字符串當中是否全都為數字或者字母或者字母與數字組合
istitle():判斷字符串中首字母是否為大寫，其他是否為小寫，其他不為小寫則為否
isupper()/islower():is開頭的就是判斷一個字符串是否展示位都是大寫后者都是小寫
2，列表
索引與切片賦值
list1=[1,88,'test','duoceshi']
list1[0]=666 結果為 [666,88,'test','duoceshi']
list1[2:]=sdada 結果為 [1,88,s,d,a,d,a]
append():添加一個元素
list1=[1,2,3,4,5]
list1.append('a') 結果為 [1,2,3,4,5,a]
extend():連接兩個列表
list1=[1,2,3,4,5] list2=[6,7,8]
list1.extend(list2) 結果為 [1,2,3,,5,6,7,8]
insert():在指定位置前插入一個元素
list1=[1,2,3,4,5]
list1.insert(0,'test') 結果為 [test,1,2,3,4,5]
remove():刪除元素
list1=[1,2,3,4,5]
list1.remove(2) 結果為 [1,3,4,5]
索引刪除值
list1=[1,2,3,4]
del list1[0] 結果為 [2,3,4]
index:在列表中查找元素所對應的索引值
list1=[1,2,3,4]
list1.index(2) 結果為 1
sort：實現列表的升序排列
list1=[1,2,3,4,1]
list.sort() 結果為 [1,1,2,3,4]
sorted:實現降序排列
list1=[1,2,3,4,1]
print(sorted(list1,reverse=Trrue))
結果為 4,3,2,1,1
reverse函數：列表元素反轉
list1=[1,2,3,4]
list1.reverse() 結果為 [4,3,2,1]
pop函數
list1=[1,2,3,4]
pirnt(list1.pop(0)) 結果為 1
3，元組
格式：a=(1,2,3)
元組轉化為列表
b=list(a)
print(b)
列表轉化為元組
a=tuple(b)
print(a)
4，字典
格式：a={'name':'zhangsan','age',18}
1,添加鍵
a[sex]='nan'
2，取出鍵
a.keys()
print(a)
3,取出值
a.values()
print(a)
4,取出具體鍵的值
print(a['name'])
5,字典添加元素
a.setdefault('sex','男')
6，刪除字典
del (a)
print(a)
7,刪除指定的鍵，連同值也刪除
del(a['name'])
8,字典的遍歷
for key in a:
print(key,a[key])
9,用items完成遍歷
for key,values in a.items():
print(key,values)
10,POP(key)函數，刪除指定鍵并返回刪除的值
print(a.pop('name')) print(a)
結果為[age:18]
11,clear()清空字典所有項
a.clear()
print(a) 結果為[]
12,get(key),通過key獲取值，當鍵不存在，返回none
print(a.get('name')) 結果為[zhangsan]
13,fromkeys函數可以給具體的鍵指定值
print({}.fromkeys(['name'],'age'))
print({}.fromkeys(['name'],'age'),'duoceshi')
14,popitem
print(a.popitem())
print(a)
15,update()函數利用一個字典變更另一個字典
b={'sex':'nan'}
a.update(b)
print(a)
5，集合
1、可變集合set
list1 = [1,1,1,88,88,'duoceshi','dcs']
set1 = set(list1)
set1.add('dcs')
set1.remove('dcs')
set1.pop() #把最前面這個給刪除了
set1.clear()
print (set1)
2、不可變集合frozenset
test = 'hello'
a = frozenset(test)
b = a.copy()
b.add('888') #報錯AttributeError: 'frozenset' object has no attribute 'add'
print (b)
五、?模塊
1，time模塊：
time.time-----1970年到今天過了多少秒
time.ctime------顯示當前日期
time.sleep(2)--------休眠
time.asdtime()--------顯示當前日期
time.strftime('%Y-%m-%d-%H-%m-%s')
2，random模塊
random----隨機生成0開頭的浮點數
random.random()------隨機生成小于1的小數
random.randint(1,5)------隨機取一位整數，包含開始
random.randrange(1,100,2)-----根據range函數：(起始，結尾，隔位)，支取1個
random.randrange(0,101,2)---取1-100之間的偶數
a=[1,2,3,4,5,6]
random.choice(a)---------隨機取a列表中的一個數字
random.sample(a,3)-----列表中隨機取自己定義的個數的值
random.shuffle(a)---------重新打亂a列表的順序(先洗牌)
print(a)-------再打印
3，String模塊
string.digits-----生成0123456789
string.hexdigits------生成0123456789abcdefABCDEF
string.ascii_uppercase----生成26個大寫字母
string.ascii_lowercase-------生成26個小寫字母
string.ascii_litters------生成26個小寫字母和26個大寫字母,
4，加密算法
base64位編碼
1，加密
a=base64.b64encode(b'123456')
print(a) 結果為 b'MTIzNDU2'
2，解碼
c=base64.b64decode(a)
print(b) 結果為 b'123456'
MD5加密
在線加解密：
http://encode.chahuo.com/
https://tool.oschina.net/encrypt?type=2
md5=hashlib.md5()#創建一個對象：md5
md5.update(b'123456')#通md5對象來調用update方法對某個值進行加密處理過
print(md5.hexdigest()) #通過hexdigest將md5加密密碼進行十六進制轉換輸出
結果為：e10adc3949ba59abbe56e057f20f883e
5，os模塊
a='D:\\www'
b='qqq.txt'
os.gitcwd()#獲取當前操作文件的路徑
os.path.isfile(a) #判斷是不是文件
os.path.isidr(a) #判斷是不是目錄
os.path.exists(a) #判斷文件或目錄是否存在
os.listdir(a) #列出指定目錄下的目錄或文件
os.path.split(a) #分割文件名與目錄
os.path.join(a,b) #連接目錄與文件名或目錄
os.mkdir(a) #創建一個目錄
os.rename(old,new) #更改目錄名稱
六、判斷與循環
1，判斷
1、if條件判斷語句單分支
if 判斷條件：
語句塊1……
else：
語句塊2……
2、if條件判斷語句多分支
if 判斷條件1：
語句塊1……
elif 判斷條件2：
語句塊2……
else:
語句塊n
2，循環
1，?while循環語句
while 條件表達式：
循環體語句
while什么時候進入循環？當循環條件成立時，進入循環
while什么時候退出循環？當循環條件不成立時，退出循環
注意：在寫while循環語句時一定要讓循環條件發生變化，否認很容易陷入死循環中
2，?循環語句
1、for循環的語法格式如下：
for ... in ...
語句塊
2、先熟悉下range()函數：如果需要遍歷一個數字序列，可以使用python中內建的函數range()
for i in range (10) #打印0到9、不包含10
for i in range (1,10) #打印1到9、不包含10
for i in range (0,10,2) #打印結果：0，2，4，6，8不包含10
3,?continue語句
用法：continue語句用來告訴Python跳過當前循環的剩余語句，然后繼續進行下一輪循環。
4,break語句
用法：語句會立即退出循環，在其后邊的循環代碼不會被執行。
七、封裝
(1)封裝定義：
(2)封裝的優點：
2.1封裝數據可以很好的保護隱私，(將不需要對外提供的內容都隱藏起來)
2.2 封裝方法主要原因是隔離復雜度
2.3 封裝提高了代碼的復用性。
2.4隱藏對象的屬性和實現細節，提供公共方法對其訪問
(3)python類的封裝兩種
3.1公用(共有)：類中的變量和方法公用；他們名稱前都沒有下劃線，公有的變量和方法，在類的外部，內部，以及子類都可以方位
3.2私有：在類中的變量或方法下，下劃線__開頭命名，則改變量或方法為私用，私有的變量和方法，只能在本類內部使用，類的外部以及子類都五法使用。
私有屬性：
格式：__屬性名=值? ? 在類的外部不能使用(對象不能調用屬性)
私用化封裝后的限制：
(1)類 可以訪問
(2)類外/對象外? 不可訪問
(3)子類和子類對象? 不可訪問
八、繼承
繼承特性
1、繼承：類的繼承是面向對象程序設計的一個重要思想，繼承時子
類可以繼承父類的內容，包括成員變量和成員函數。
2、在繼承中一個類被另外一個類繼承這個類稱之為父類也稱之為基
類，則另外一個類則為子類也稱之為派生類。
九、多態
1、多態是以繼承和重寫父類方法為前提，對所有子類實例化產生的對象
調用相同的方法，執行產生不同的執行結果。
2、例如同樣是人，但是當問起一個人的職業時會有不同的結果，可能是
軟件測試工程師，可能是HR
3、一個對象的屬性和行為不是由他所繼承的父類決定的，而是由其本身
包含的屬性和方法決定的
==========================================================
案例2：
評價：
1、案例寫的詳細，但是總結就是筆記
2、總結根據自己的情況，進行總結
一、?Python定義
二、?Python特點
三、?Python的不同點：
膠水語言、輸出語句(print)、注釋(Ctrl+/、#、’’’)
格式化輸出：基本格式：('%d'%a)
%s :字符串 (采用str()的顯示)
%c :單個字符
%d:十進制整數
%i :十進制整數
%o:八進制整數
%x:十六進制整數
%f:浮點數
%% :百分數
常用的運算操作：算術運算(加減乘除)、賦值運算(+=)、比較運算、邏輯運算、位運算、成員運算(in、not?in)
四、?索引與切片
索引格式：str[?x]，x為索引號
切片格式：str[start_index:end_index:step]，str[::-1] 反轉
常用字符串函數：
1、str.capitalize():實現首字母大寫
2. str.count('xx')統計指定字符在當前字符串中出現的次數
3.'_'.join('xx')(拼接函數)自定義分割符，來分割當前的字符串，例如：'@'.join('xx')用@來將xx進行分割
4.分割函數 str.split('xx'):指定當前字符串中的一個字符作為分割符(用，替代字符串中的這個字符)，且返回一個列表
例如：str?=?'abcdefghigkl'
str1=?'admin:123123'
num?=?str.split('j')
print?(num) 顯示結果：['aSDfgh',?'ksl']
5.str.strip('xx'):刪除字符串開頭和結尾的字符
格式：str.strip('XX')：刪除字符串以XX字符開頭和結尾的內容
6、str.lstrip('XX')：刪除字符串以XX字符開頭的內容
print?(str.lstrip('a')) 顯示結果：bcdefjghigkl
7、str.rstrip('XX')：刪除字符串以XX字符結尾的內容
print?str.rstrip('l') 顯示結果：abcdefjghigk
rstrip 意思：刪除末尾字符
8、str.startswith('XX')：判斷字符串中以XX字符串開頭，如果條件成立返回 TRUE，
否則返回FALSE
print?str.startswith('a') 顯示結果：?True?#swith
9、str.endswith('XX')判斷字符串中以XX字符串結尾，如果條件成立返回TRUE，否則
# 返回FALSE
print?str.endswith('l') 顯示結果：True
startswith(self?prefix start end)
方法的參數
prefix 開始
end 結束
self?自己本前綴
start 身
10、find、rfind通過具體的值來找到對應值的索引位，
str.find('XX')
從字符串左邊開始查找指定的字符串，且返回的是當前字符的索引位，一旦找到第一個將停止查找，如果查找的對象不存在則返回-1
print (str.find('n'))
顯示結果：-1
print (str.find('c'))? # 左邊開始查 顯示結果：2 顯示第一個的下標，沒有顯示-1
11、str.rfind('XX')從字符串右邊開始查找指定的字符串，且返回的是當前字符的索引位，一旦找到第一個將停止查找，如果查找的對象不存在則返回-1
print? (str.rfind('k'))
顯示結果：11? # 左邊開始查
注意：取得索引都是正向索引? ，注意當出現多個同樣的字符find和rfind 是不同的
12、str.replace('XX','YY')替換指定的字符串，且可以指定替換次數
print?(str.replace('c',?'dcs'))
顯示結果：abdcsdefjghigkl
13、replace()替換字符串中的字符 ：replace(substring,newstring,max)
str.replace('XX', 'YY', 1)? #
方法中的1表示將指定字符替換的次數，從左到右開
始替換 --這里次數為1的話只會替換第一個發現的字母XX改下：
str = 'asDfghjksl'
print??(str.replace('c',?'dcs',?2))
顯示結果：
14、str.lower()將字符串中的所有大寫字母改為小寫print??(str.lower())
顯示結果(小寫)：asdfghjksl
15、str.upper()將字符串中的所有小寫字母改為大寫
print??(str.upper())?顯示結果：ABCDEFJGHIGKL
字符串判斷方法
mtehod?? 方法
以下都是字符串的判斷，結果只有true or false
17、name.isalnum()?判斷字符串是否是字母或者數字? # alnum字母和數字，小寫字母。
name?=?"1123abcdefg"
print(name.isalnum())?判斷字符串是否是字母
顯示結果：ture
print?(name.isdigit())?判斷字符串是否是數字? # digit
顯示結果：flse
18、print??(name.islower())?判斷字符串是否是小寫
顯示結果：ture
19、print??(name.isupper())?判斷字符串是否是大寫,有小寫就顯示false，只有大寫字母和漢字仍為true
顯示結果：flse
20、name.isspace() 判斷字符串是否全部由空格組成。
五、列表、元組、字典及其常用操作
列表(list)
一、定義
1.list=[1,2,3,4,5]
2.通過list()進行轉換
3.對列表操作：
通過索引賦值：格式? 列表名[ 索引]=“ 新值”
通過切片賦值：格式? 列表名[ 索引：]=“ 新值”
二、函數
1、賦值
第一種：賦值(索引方式)
a=[1,2,3,4,5,6] b=['大'，‘家’，‘好’]
a[4]='yy'
結果：[1,2,3,4,'yy',6]
注意點：1.把原來對應索引位置替換成新的值
第二種：
a[2:]='蔡瑞峰為什么這么帥'
結果：[1,2,'蔡','瑞','峰','為','什','么','這','么','帥'](從索引號為2開始被后面的字符替代)
2、append? ?添加函數(默認添加在列表最后)
格式：變量名.append('hello')
舉例：a.append('hello')
結果：[1,2,3,4,5,6,'hello']
3、extend? ? ?拼接函數(兩個列表的拼接)
格式：變量名1.extend(變量名2)
舉例：a.extend(b) (將b拼接在a后面)
4、insert? ? ? 插入函數
1、根據索引值插入值：(如果索引已存在插入，之前的索引值+1， 不存在出入就插入指定索引值，超出索引值也是在最后顯示)
第一種情況：超出的索引值
s?=[1,2,3,4,5]?#定義一個列表
s.insert(10,'hello')?#給索引值為10的位置在最后一位
print(s)?#[ 1, 2, 3, 4, 5,'hello']
備注:超出索引范圍，都默認顯示在列表的最后一位
第二種情況：存在的索引值
s?=[1,2,3,4,5]?#定義一個列表
s.insert(0,'hello')?#給索引值為0的位置插入一個具體的值
print(s)?#['hello', 1, 2, 3, 4, 5]
備注：插入的值是當前指定的索引，原列表中的索引加1或(往后推一位)
第三種情況：負向索引
s?=[1,2,3,4,5,6]?#定義一個列表
s.insert(-1,'hello')?#給索引值為0的位置插入一個具體的值
print(s)?#[1, 2, 3, 4,5,'hello', 6]
5、remove? ?刪除
方法一：刪除的是具體的值
第一種情況：有對應的值，有且只有一個
c=[1,2,3,4,5,6,"a"]
c.remove(2)
print(c)
打印結果： [1, 3, 4, 5, 6, 'a']
第二種情況： 刪除有多個一樣的值，只刪除第一個
l?=?['c',?1,?2,?3,?4,'c'?,5,?6,?'c']??# 定義一個列表
l.remove("c")??# 移除l列表中對應的具體值
print(l)????#顯示結果 [1, 2, 3, 4, 'c', 5, 6, 'c']
備注：多個同樣的值，從左開始刪除第一個值，
# 移除l列表中對應的具體值
第三種情況：刪除不存在的值，報錯，不在刪除的列表中
l?=?['c',?1,?2,?3,?4,?5,?6,?'s']??# 定義一個列表
l.remove("a")??# 移除l列表中對應的具體值
print(l)??# 顯示結果：報錯??? 刪除的內容不存在列表中
6、del? ? 刪除
方法二：del 刪除
第一種情況：
del? 通過索引 刪除列表種對應的元素
# l1 =[1,2,3,4,5] #定義一個列表
# del l1[4] #刪除對應列表中對應的索引值對應的值
# print(l1) #打印結果：[1, 2, 3, 4]
第二種情況: 超出索引值，刪除列表是錯誤的
l1?=[1,2,3,4,5]?#定義一個列表
del?l1[6]?#刪除對應列表中對應的索引值對應的值
print(l1)?#顯示結果：list assignment index out of range
備注：報錯，列表索引超出范圍
7、sort? ? ? ? 升序
場景1、l1?=[5,4,3,2,1]?#定義一個列表
l1.sort()?#通過sort來對列表進行升序排序
print(l1)?#[1, 2, 3, 4, 5]
場景二：字符和數值在一個列表中不能進行排序，報錯
c=[1,2,"a",3,4,3,5,6,"a"]
c.sort()
print (c)
報錯TypeError: '
場景三：列表中出現多個相同的數值排序(根據數值的大小并列)
d=[1,2,9,4,3,6,6,5,6]
d.sort()
print(d)
打印結果：[1, 2, 3, 4, 5, 6, 6, 6, 9]
8、sorted? ? 降序
sorted要配合reverse一起使用才能實現升序與降序
格式：sorted(變量名，reverse=True)降序
sorted(變量名，reverse=False)升序
9、reverse? 反轉
格式：變量名.reverse()(實現列表中元素反向排列)
10、pop? 刪除(默認刪除最后一個元素，也可以通過索引來刪除)
格式：變量名.pop()
變量名.pop(索引號)
10、場景一：index根據列表中具體的值得出索引值
d=[1,2,9,4,3,6,6,5,6]
print(d.index(2))
打印結果：1
------------------------------------------------------------------------------------------------------------
元組(tuple)
一、定義
元組定義后由于不可直接修改則相對于代碼來說要更加安全
1.a=(1,1,2,3,4,5,)
2.通過tuple()進行轉換
3.tuple(a)=tuple(b)+tuple(c) 元組的拼接
注意：元組不能進行元素的修改與添加，因此要修改元祖內的數據需要通過list(tuple)將元組轉化為列表
-------------------------------------------------------------------------------------------------------------------------------------------------------
字典(dict)
1 python中的字典：dict類型
2 鍵值對組成
3 鍵是唯一，值可以不唯一
4 {} 英文的大括號 也叫花括號
5 字典中鍵值是一個整體，如有多個鍵值對要用英文的,逗號隔開
6 整數類型不需要加單雙引號外，其它都需要加單雙引號
7 鍵和值用英文的:冒號? 比如：name:zhangsan
(1)定義一個字典d ={'name':'zhangsan','age':18} #定義一個字典print(type(d))
字典的類型
print(d) #打印結果為：{'name': 'zhangsan', 'age': 18}
(2)列表轉換成字典步驟 重點：(使用dict 就可以轉換)
第一步：定義一個列表
l =[('name','zhangsan'),('age',18)]
第二步：使用dict 將列表轉換成字典
di_ct=dict(l)#將列表轉換成為字典
第三步：查看字典的類型
print(type(di_ct)) #字典類型
第四步：在打印字典
print(di_ct) #{'name': 'zhangsan', 'age': 18}
備注：字典轉換是鍵與值一組，所以是2個值一組
(3)字典中添加鍵值對： 格式：變量名[鍵] =值
注意：字典中添加新的的鍵和值
d ={'name':'zhangsan','age':18}#定義一個字典
d['scroe']=100
print(d) #{'name': 'zhangsan', 'age': 18, 'scroe': 100}
(4)字典中有鍵，替換值(鍵不變，值變)
c= {'name': 'zhangsan', 'age': '18'}
c['name'] = 200
print(c) # 打印結果：{'name': 200, 'age': '18'}
小結：《1》、給字典中增加一個鍵值對：如原字典內沒有相同的鍵值對則新增一個
《2》、如原有字典中有相同的鍵，則會將對于的鍵的值進行重新賦值''
3、通過keys取出對應的鍵
d?={'name':'lis','age':18}?#定義一個字典
print(d.keys())?#(['name', 'age'])
# 通過keys來取出對應的鍵
print(type(d.keys()))?#
4、通過values 取出字典中對應的值
v={'name':'lis','age':18}?#定義一個字典
print(v.values())?#['lis', 18]
5、通過鍵來獲取對應鍵的值
k?={'name':'lisi','age':18}?#定義一個字典
print(k['name'])?#lisi
6、6.1添加設置默認鍵值setdefault
mr ={'name':'lis','age':18} #定義一個字典6.1默認值不存在的情況下，直接添加鍵值mr.setdefault('scroe',100)
1
2
3
4
5
6
print(mr)?#{'name': 'lis', 'age': 18, 'scroe': 100}
6.2 已有鍵值，在使用默認鍵值不會進行修改，或者增加
mr.setdefault('name','zhangsan')
print(mr)?#{'name': 'lis', 'age':? 18, 'scroe': 100}
備注：已經存在的值的優先級>默認值
6.3 直接修改 值，顯示最新修改值? (修改默認值優先級小于直接添加的字典值)
mr['name']='wangwu'
print(mr)?#{'name': 'wangwu', 'age': 18, 'scroe': 100}
7、刪除鍵：(刪除鍵，值也沒有了)
1
2
3
dellkey={'name':'zhangsan','age':18}
del?dellkey[?'name']
print?(dellkey)
注意點：鍵和值都要用引號，除數值外
8、使用for 循環獲取key
1
2
3
d?={'name':'zhangsan','age':18}
for?k?in?d:
print(k)??#拿到的是：鍵 值不拿
9、使用for循環獲取key，values
1
2
3
s?={'name':'zhangsan','age':18}
for?k?in?s:
print(k,s[k])
10、# 通過items()方法來獲取對應鍵值對
1
2
3
t?={'name':'zhangsan','age':18}
for?k,v?in?t.items():
print(k,v)
11、'通過pop函數刪除指定的鍵，打印返回對應鍵的值'''
方法一：pop刪除指定的鍵，返回對應的值
1
2
d2?={'name':'zhangsan','age':18}
print(d2.pop('name'))?#zhangsan
方法二：popitem在字典刪除鍵值對，一般默認在末尾
1
2
d?={'name':'zhangsan','age':18,'':100}
print(d.popitem())?#('', 100)
備注：打印結果：字典中最后一個鍵值
12、clear??來清空當前字典中的鍵值對，返回一個空字典
1
2
3
d3?={'name':'zhangsan','age':18}
d3.clear()?#通過clear()來清空當前字典中的鍵值對
print(d3)?#? 打印結果：{}清空后返回就是一個空字典
13、get? ?，get通過鍵獲取對應的值
1
2
3
4
5
6
7
d?={'name':'zhangsan','age':18,'':100}
print(d)?#{'name': 'zhangsan', 'age': 18, '': 100}
print(d.get('name'))?#zhangsan #通過鍵獲取值
print(d.get(''))?#100
print(d.get('age'))?#18
print(d.get('score'))?#None? #通過不存在的鍵，返回的是none
print(d.get(100))?#None????? #通過值去獲取，返回時的none
14、快速生成一個新字典的方法fromkeys
方法一：
第一種情況：生成一個新的字典的鍵
print ({ }.fromkeys(['name','age']))??#{'name': None, 'age': None}
第二種情況：生成一個字典的鍵和值
print({}.fromkeys(['name','age'],'a')) #{'name': 'a', 'age': 'a'}
方法三：快速生成字典，并賦同樣的值
1
2
d={'name':'zhang','age':18}
print(d.fromkeys(['name','age'],'c'))?#{'name': 'c', 'age': 'c'}
15、update? 方法 將多個字典合并
1
2
3
4
d1?={'name':'zhangsan','age':18}?#定義一個字典
d2={'scroe':100}?#定義一個字典
d1.update(d2)?#通過update方法將d1字典和d2字典進行合并
print(d1)?#{'name': 'zhangsan', 'age': 18, 'scroe': 100}
備注：合并字典以后，在d1表中
16、copy 復制字典
1
2
3
4
s={"name":"zhangsan","age":15}
c=?s.copy()
print?(c)
print?(s)
17、del刪除字典
1
2
3
4
5
6
7
8
#場景一：
d={"name":"lixi","age":18}
del?d
#場景二：刪除鍵
d={"name":"lixi","age":18}
print(d)
# del (d["name"])
# print(d)
備注：has_key? 在python2中有，在python3中不存在
六、?Python中的語句
輸入語句input(‘xxx’)，輸出語句：print(‘xxx’)
If語句：單分支，多分支，if嵌套
While循環語句
For循環語句
Continue語句(跳過指定條件，繼續執行后面)
Break語句(退出循環，不再執行break后面的內容)
七、?Python中的函數
1、函數：一個工具，隨調隨用
優點：
(1)降低代碼冗余
(2)增加代碼的復用性，提高開發效率
(3)提高程序擴展性
(3)函數有兩個階段：定義階段，調用階段。
(4)定義時：只檢查函數體內代碼語法，不執行函數體內代碼。
(5)比如：我們存儲的過程，就是把所有的語句塊，調用
(6)封裝：就是把代碼片段放在函數當中
2、自定義函數
def 自定義函數名()：
函數體
函數 的調用格式 函數名()
舉例：def fun()：
print(‘請輸入密碼：’)
調用：fun()
調試時調用多個函數：if __name__=='__main__'：
從其他模塊調用：import aa (導入aa模塊)
aa.fun( )(調用aa模塊的fun函數)
3、可變長元組(*list)與可變長字典(**dict)
4、全局變量與局部變量
5、return(函數的返回值)
6、內置函數(format、zip、open、with open、abs、sum、map)
6.1format(格式化輸出函數)
a ='{}'.format('hello','ni','hao')
print(a) #打印結果 hello
6.2?zip(打包函數)
打包：zip(a，b) print(list(zip(a，b)))
解壓：s，c=zip(*zip(a，b)) print(list(s))
6.3?open(打開與編輯文件)
open完整的語法格式為：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
file: 必需，文件路徑(相對或者絕對路徑)。
6.4?with?open(open的擴展)
url?=r'C:\Users\Administrator\PycharmProjects\untitled1\requester\ss.py'
with?open(url,'r',encoding='utf-8')as o:
a=o.read()
print(a)
八、?Python中的模塊
模塊的導入(import)
Time模塊(時間的顯示)
time.time()(顯示從1970年到現在一共經歷的秒數)
time.ctime()(顯示當前實時時間)
time.sleep()(休眠，括號內加上數字表示休眠多少秒后再執行)
time.strftime()(自定義時間格式：%Y-%m-%d-%H:%M:%S)
time.asctime()(轉換為asc碼形式顯示時間)
3、random模塊
random.random() 隨機生成0開頭的浮點數
random.randint(1,4) 隨機取一個在1-4范圍內的數(不包含4)
random.sample(a,4) 在a中隨機抽取4個數生成一個列表
random.randrange() 遞增隨機取一個值
random.choice(a) 在a列表中隨機取一個值
random.shuffle() 隨機洗牌(將列表中的所有元素隨機調?動輸出)
string模塊(字符串)
string.digits 生成0-9的整數
string.hexdigits 生成0-9的整數+大小寫的a-f和A-F
string.ascii_uppercase 生成26個大寫字母
string.ascii_lowercase 生成26個小寫字母
4、加密與解密
5、OS?模塊(對于目錄文件路徑常用的模塊)
OS.getcwd() 獲取當前文件對應的目錄(相對路徑)
os.path.isfile(a_path) 判斷當前是否為文件，返回布爾值
OS.path.isdir() 判斷是否為目錄
os.path.exists(a_path) 判斷文件(目錄)是否存在
os.mkdir() 創建目錄mkdir(a，755)注意：目要設置權限，755或者777
os.remove(a_path) 刪除文件(無法刪除目錄)
os.listdir(a_path) 獲取當前目錄下所有的文件和目錄
os.path.split(a_path) 對某個路徑進行分割，要求：把路徑?分隔以后，再通過索引取出分隔后的值，在使用得到的值進行拼接，拼接成新的路徑
例如：
#第一步先使用split分割 a_path ="D:\\bao" print(os.path.split(a_path)) # 第二步在根據索引取值 path=os.path.split(a_path)[0] #第三步在拼接 b_path=os.path.join(path,11.py) print(b_path)
os.path.abspath(a_path) 通過名稱獲取當前名稱對應的路徑(絕對路徑)
os.rename(old_path,new_path) 重命名目錄和文件
6、re模塊(正則匹配)
#?預定義字符集匹配：
\ d:? ??數字0-9
\D:? ?非數字
\s:? ?空白字符
\n:? ?換行符
\w:? ??匹配字母數字
\W:??匹配非字母數字
^：表示的匹配字符以什么開頭
$：表示的匹配字符以什么結尾
*：匹配*前面的字符0次或n次?#eg：ab(*?能匹配a?匹配ab?匹配abb?)
+：匹配+前面的字符1次或n次
?：匹配?前面的字符0次或1次
{m}：匹配前一個字符m次
{m,n}：匹配前一個字符m到n次(包括n次)，m或n可以省略，mn都是
1、findall? ? #從第一個字符開始查找，找到全部相關匹配為止，找不到返回一個空列表[]
2、compile? ?#編譯模式生成對象，找到全部相關匹配為止，找不到返回一個列表[]
3、match? ???#?從第一個字符開始匹配，如果第一個字符不是要匹配的類型、則匹配失敗并報錯#?注意：如果規則帶了'+'，則匹配1次或者多次，無' +'只匹配一次
4、search? ?#從第一個字符開始查找、一找到就返回第一個字符串，找到就不往下找，找不到則報錯
九、類與對象
1、面向對象的基本概念：類(所有具有相同屬性和方法的對象的集合)、對象(通過類定義的數據結構實例)、方法(類中定義的函數)、類變量(實例中對象公用的，定義在類中且在函數體之外)、實例變量(用self修飾的變量)
2、定義與使用類
定義格式：class?people()
Def?__init__(self,name)
創建對象：p=people(‘xx’)
3、類中的實例方法、動態方法、靜態方法
實例方法
定義：第一個參數必須是實例對象，該參數名一般約定為“self”，通過它來傳遞實例的屬性和方法(也可以傳類的屬性和方法)；
調用：只能由實例對象調用。
動態方法(類方法classmethod)
定義：使用裝飾器@classmethod。第一個參數必須是當前類對象，該參數名一般約定為“cls”，通過它來傳遞類的屬性和方法(不能傳實例的屬性和方法)；
調用：實例對象和類對象都可以調用。
靜態方法(staticmethod)
定義：使用裝飾器@staticmethod。參數隨意，沒有“self”和“cls”參數，但是方法體中不能使用類或實例的任何屬性和方法；
調用：實例對象和類對象都可以調用。
4、類的三大特性(封裝特性、繼承特性、多態特性)
===============================================================
總結
以上是生活随笔為你收集整理的python自动计算多个教学班的优秀率_第二个月课堂009python之总结(002)的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： win10配置mysql8.0_Win1
- 下一篇： websocket python爬虫_p