PYTHON基礎二
一. 註釋node
#python e:\py1\01.py
#python e:\Studypython\py2\01.pypython
print("444444444444444444444444444444444444444444444444444444444444444444444444444"mysql
# 單行註釋sql
'''shell
這是多行註釋
'''windows
二. print()輸出api
#打印到屏幕上的一些信息 課題接受多個字符串
#用逗號分隔 遇到逗號會輸出一個空格
#能夠輸出數字
#還能夠運算數組
print("mysql name lickr , onckie function")
print(4+2)
print(8)
print("4+2=",6)
#print ()是輸出函數app
三. input 交互 數據轉換dom
# input
# 做用輸入(阻塞)輸入的內容保存在age
# int integer = 整數 把字符串轉成int 用int(被轉的數據)
# str string = 字符串 把數據轉換成i字符串 用str(被轉的數據)
# 注意 input 接受的全部數據都是字符串 即使你輸入的數字 可是依然會當作字符串來處理
age=input("請輸入你的年齡:")
print("age=",age)
四. python :如下是數據類型
number(數字)
整數
浮點數
複數
string(字符串)
布爾值(true/false)
none(空值)
list(列表)
tuple(元組)
dict(字典)
set(集合)
五. 標識字符
標識符(變量) : 是字符串(注意:字符串未必是標識符)
規則: 只能又數字字母下劃線線組成
不能數字開頭
不能使用python的關鍵字
區分大小寫
見名知意
不能以數字開頭
保留字符不能被使用的
變量名不能以大寫英文字開頭
在python 裏不區分 變量(var)和常量 (const)
在python 全部都是可變的量
在python 中全部用所有大寫的變量名來表明次變量爲常量
做用: 給變量 函數等命名的
注意: 在python3中 非ascll標識符也是容許的 支持萬國碼 utf-8 undcode
在哪python 2.0以上打印中文 必須加上u 和字符集聲明 在2.0 到2.9的版本只支持 Assic 默認編碼
六. 變量與常量
程序是之上而下執行:
變量(var): 程序能夠操做的存儲空間
程序在運行期間能夠改變的數據
每一個變量都特定的類型
做用: 將不一樣的數據存儲在內存中
列如: age=10
數據的存儲 : 變量名=數據值
注意:變量必須先定義在使用
刪除變量: del 變量名
刪除後變量不能引用了
type() 查看數據類型
name=22
print(type(name)) 查看name數據類型
print(id(name)) 查看變量的地址
常量(const): 數據在運行的時候不能改變的量
在python 中全部用所有大寫的變量名來表明次變量爲常量
七. number 數據類型
# 分類 :整數 浮點數 複數
# 整數在python中能夠處理任意大小的數字 在程序中和數學寫法同樣
# 單個定義變量
num22=10
num23=num22
# 連續定義多個變量
num=num1=num2=10
print(num,num1,num2)
#查看變量的地址
print(id(num1))
# 交互式賦值定義變量
num8,num9=6,7
print(num8,num9)
# 浮點數:由整數和小數部分組成 浮點數能夠四捨五入
a=1.22
b=2.222
# 複數: 實數和虛數組成
a+bj
八. 數字類型轉換
print(int(1.9)) # 1 將1.9浮點數轉成整數1
print(float(1)) #1.0 將整數1轉換成浮點數1.0
print(int("123")) #123 將字符串"123"轉換成整數123
print(float("12.22")) #12.22 將字符串"12.22"轉換成浮點數12.22
print(int("+123")) #123 注意: 正負號只能放在前面
print(int("-123")) #-123 若是有其餘字符會報錯
九. 數學功能函數
a=-100
a2=abs(a) #求絕對值
print(a2) #100
#比較兩個數大小
b=100 #若是前面b>c 返回1 b<c返回-1 相等返回0
c=20
print((b>c)-(b<c)) #1
print(max(b,c)) #100 給定的參數返回最大的值
print(min(b,c)) # 20 給定的參數返回最xiao的值
#求x的5次方 2^5
print(pow(2,5)) #32 pow()求某某的n次方
#四捨五入round(x,[,n]) 返回浮點數x的四捨五入的值 若是給n值 則表明舍入到小
print(round(3.456)) #3
print(round(3.7)) #4
print(round(3.72228,2)) #3.72 後面那個參數表示保留幾位
print(round(3.546,1)) #3.5 後面那個參數表示保留幾位
#導入庫
#庫:封裝了一些功能
#import math 意思就是導入數學相關的庫
#math 數學相關的庫
import math #意思就是導入數學相關的庫
向上取整
print(math.ceil(17.9)) #18
print(math.ceil(17.1)) #18
向下取整
print(math.floor(17.9)) #17
print(math.floor(17.1)) #17
返回整數部分 和小數部分
print(math.modf(22.55555)) #(0.5555500000000002, 22.0)
print(math.sqrt(25)) # 5.0#開平方
import random #引入隨機數模塊
#隨機數
print(random.choice([1,2,3,4,5,6])) #表示隨機qu一個數組裏面的數
#意思重數列中隨機取一個
print(random.choice(range(5))) #意思生成1到5的數字
print(random.choice("ABCDEF")) #表示隨機取一個數組裏面的字母
#生產一個一到10的隨機數
sui=random.choice(range(10))+1
print(sui)
# 從指定範圍，按指定的奇數遞增的集合中選取一個隨機數
# random([start,],stop[,step])
# start 指定範圍的開始值 包含在範圍內
# stop 指定範圍的結束值 不包含在範圍內
# step 指定的基數
print(random.randrange(1,100,2)) #一到100的奇數 可是不包含一
print(random.randrange(100)) # 從0到100 取一個隨機數 可是不包含100
print(random.random()) #生產0到1的隨機數 可是不包含1 的浮點數
list=[1,2,3,4,5,6]
random.shuffle(list) #將list裏面的數據 隨機排序
print(list)
#隨機生產一個實數 他在[3,9]範圍
bb=random.uniform(3,9)
print(bb)
實列 : 數學函數簡單彩票系統 import random #導入隨機數模塊 import math #到人數學模塊 num=int(input("請輸入你的號碼:")) res=random.choice(range(100))+1 if num==res: print("你中獎了") else: print("你沒中獎了")
十. 運算符
# 表答式: 有變量 常量和運算符組成的式子
# 閱讀:表答式
# 功能：
# 值:
# 算術運算符和算術運算表達式
# 算術運算符
# + - * / % ** //
# 加 減 乘 除 取模 冪 取整
# 算術表達式:
num1=5
num2=3
print(num1+num2) # 8
print(num1-num2) # 2
print(num1*num2) # 15
print(num1/num2) #1.6666666667
print(num1%num2) # 2
print(num1**num2) #125
print(num1//num2) #1
賦值運算符 =
變量=表達式
aa=5
符合運算符
+= a+=b a=a+b
*= a*=b a=a*b
/= a/=b a=A/b
%= a%=b a=a%b
**= a**=b a=a**b
//= a//=b a=a//b
十一. if . for . while . break . 語句:
# 格式:
# if表達式:
# 語句
num=6
num2=7
if num==num2:
print("yes")
else:
print("no")
# -*- coding: UTF-8 -*-
# f 語句的判斷條件能夠用>（大於）、<(小於)、==（等於）、>=（大於等於）、<=（小於等於）來表示其關係。
# 當判斷條件爲多個值時，可使用如下形式：
# if 判斷條件1:
# 執行語句1……
# elif 判斷條件2:
# 執行語句2……
# elif 判斷條件3:
# 執行語句3……
# else:
# 執行語句4……
num = 5 if num == 3: # 判斷num的值 print 'boss' elif num == 2: print 'user' elif num == 1: print 'worker' elif num < 0: # 值小於零時輸出 print 'error' else: print 'roadman' # 條件均不成立時輸出
# 死循環 表達式永遠爲真的循環
while 2: print("哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈") var = 1 while var == 1 : # 該條件永遠爲true，循環將無限執行下去 num = raw_input("Enter a number :") print "You entered: ", num
# while 表達式:
# 語句
# else:
# 語句1
# 邏輯:在條件語句（表達式）爲else時執行else的"語句2"
a=1 while a<=3: print("真的") a+=1 else: print("假的")
#練習if語句
aa=int(input("請你輸入一個數是不是奇偶:"))
if aa%2==0:
print("是偶數")
else:
print("是奇數")
# aa=153%10 #3 各位 # aa=153//10 #15 # aa=153//10%10 # 5 十位 #aa=153//100 #1 百位 # #求水仙花樹 num =int(input("請輸入一個數:")) aa=num%10 bb=num//10%10 cc=num//100 if num==aa**3+bb**3+cc**3: print("是水仙花數") else: print("不是一個水仙花數")
#找最大值 num1=int(input()) num2=int(input()) num3=int(input()) max=num1 #假設 if num2>num1: max=num2 if num3>max: max=num3 print("max=",max)
# # 輸出一到五的值: num=0 while num<5: num=num+1 print(num) # 1 # 2 # 3 # 4 # 5 # # 計算100一百的和 sum=0 num=1 while num<=100: sum+=num num+=1 print(sum) #5050 # # 打印字符串沒一個 str="ABCDEFGAAAAAAAAAAA" index=0 while index<len(str): print( index,str[index]) index+=1 # 1 ==== B # 2 ==== C # 3 ==== D # 4 ==== E # 5 ==== F # 6 ==== G # 輸出全部三位數的水仙花數 num=100 while num<=999: a=num%10 b=num//10%10 c=num//100 if num==a**3+b**3+c**3: print(num) num+=1 # 153 # 370 # 371 # 407 # 判斷輸入一個數是否是質數 # num=int(input("輸入一個數是否是質數:")) # if num==2: # prin("是質數") # index=2 # while # 計算字符串的下標的和 # str=input("請輸入字符串:") index=0 sum=0 while index<len(str): if str[index]>="0" and str[index]<="9": sum+=int(str[index]) index+=1 print(sum) 字符串比較大小是比的ASCII的值
# for 語句
# 格式:
# for 變量名 in 集合
# 語句
for aa in 'Python': # 第一個實例 print ('當前字母 :', aa) # 當前字母 : P # 當前字母 : y # 當前字母 : t # 當前字母 : h # 當前字母 : o # 當前字母 : n
fruits = ['banana', 'apple', 'mango'] for bb in fruits: # 第二個實例 print ('當前字母 :', bb) # 當前字母 : banana # 當前字母 : apple # 當前字母 : mango
# range() 函數 列表生成器
# 功能:生成數列
print(range(10)) #range(0, 10) for aa in range(5): print(aa) #0 1 2 3 4
for b in range(2,20,2): print(b) # # 2 # 4 # 6 # 8 # 10 # 12 # 14 # 16 # 18
# break語句用來終止循環語句，即循環條件沒有False條件或者序列還沒被徹底遞歸完，
# 也會中止執行循環語句。
# break語句用在while和for循環中。
# 注意只能結束最近的循環 就是當前循環
# 注意循環中能夠有else語句 break致使循環截止 不會執行else裏的語句
#!/usr/bin/python # -*- coding: UTF-8 -*- for letter in 'Python': # 第一個實例 if letter == 'h': break print ('當前字母 :', letter) # 當前字母 : P # 當前字母 : y # 當前字母 : t
var = 10 # 第二個實例 while var > 0: print ('當前變量值 :', var) var = var -1 if var == 5: # 當變量 var 等於 5 時退出循環 break # 當前變量值 : 10 # 當前變量值 : 9 # 當前變量值 : 8 # 當前變量值 : 7 # 當前變量值 : 6
# 注意循環中能夠有else語句 break致使循環截止 不會執行else裏的語句
num=1
while num<=10:
print(num) # 1 2 3
if num==3:
break
num+=1
else:
print("由於有braek就不會執行else中的語句")
# Python continue 語句跳出本次循環，而break跳出整個循環。
# continue 語句用來告訴Python跳過當前循環的剩餘語句，而後繼續進行下一輪循環。
# continue語句用在while和for循環中。
# 當前最近的循環
for letter in 'Python': # 第一個實例 if letter == 'h': continue print ('當前字母 :', letter) # 當前字母 : P # 當前字母 : y # 當前字母 : t # 當前字母 : o # 當前字母 : n #
var = 10 # 第二個實例 while var > 0: var = var -1 if var == 5: continue print ('當前變量值 :', var) # 當前變量值 : 9 # 當前變量值 : 8 # 當前變量值 : 7 # 當前變量值 : 6 # 當前變量值 : 4 # 當前變量值 : 3 # 當前變量值 : 2 # 當前變量值 : 1 # 當前變量值 : 0 #
十二. 運算符和表達式
# 位運行算
# & 按位與運算符
# 相應得位數都爲1 則該爲的結果是1不然爲0
print(5&7)
101
111
-----
101
| 按位或運算符
兩個二進制位有個位1時 結果爲1
print(5|7)
101
111
------
111
^按位抑或運算符
二進制兩位相異或
print(5^7)
101
111
----
010
~按位取反運算符
每一個二進制數據位取反
prin(~5)
<< 左移運算符
各二進制所有左移若干位 <<右側的數字決定高位捨去低位補零
print(2<<2)
>>右位移運算符
各二進制所有右移若干位 由>>右側數字決定
prin(13>>2)
十三. 關係運算符
== != > < >= <=
關係表達式
1+2>3+4
格式 : 表達式 關係運算符 表達式2
邏輯運算符
邏輯與 and
邏輯與運算符表達式 表達式1 and 表達式2
有一個爲假就爲假 其餘爲真
邏輯或 or
邏輯或運算符表達式 表達式1 or 表達式2
假假爲假 其餘爲真 (有一個爲真都爲真)
邏輯非 not 邏輯非運算符表達式 or 表達式1
就假的說的真的 真的說成假的
短路原則
表達式1 and 表達式2 and 表達式3 and 表達式4.....and 表達式n
成員運算符
in 若是在指定的序列中找到了值返回true 不然返回fales
not in 意思在指定的序列中沒有找到值返回true 不然返回fales
身份運算符
is : 判斷兩個標識符是否是引用同一個對象
is not ：判斷兩個標識符是否是引用不一樣的對象
運算符優先級
**
~ + - (一元加減)
*/ % //
+ -
>> <<
&
<= < > >=
== !=
= %= += //=
is is not
in not in
#能被4整除 可是不能被100整除 或者 能被400整除 year=int(input("請你輸入一個數字:")) if year%400==0 or(year%4==0 and year%100!=0): print("是閏年") else: print("不是閏年")
四十. 字符串
# # 什麼是字符串
# # 就是以 單引號或者雙引號引發來的任意文本
# # 'ancask的庫時時刻刻'
# # "ABC事實就是驚聲尖叫"
# # 建立字符串:
# str1="abcde骨灰盒fgaa"
# str2="abcde吾問無爲謂fgaa"
# str3="abcdefg少時誦詩書所所aa"
# # 字符串運算
# 字符串鏈接
# str6="SKSDK就是死你KsbDSKDKSKK"
# str9="ASSASADADA1111"
# str=str6+str9
# print(str)
# 輸出重複字符串
# str7="J數據的技術角度講"
# str10=str7*3
# print(str10)
# 訪問字符串中某一個字符 索引重零開始
# 字符串名[下標]
# 注意字符串不可變
# str="4555555555*5555SSSJSJSJ"
# print(str[1])
#截取字符串
# str5="ABCDEC"
# str6=str5[1:4] #從1截取到4可是不包含4
# print(str6) #BCD
# str5="ABCDEC"
# str6=str5[:4] 截取下標以前
# print(str6)#ABCD
# str5="ABCDEC"
# str6=str5[2:] #截取到末尾
# print(str6)#CDEC
#判斷:
# str="HELLOW name"
# print("name" in str ) #True
# print("str5" not in str) #True
#將字符串str 當成有效的表達式來求返回計算結果
#eval(str) 功能 將字符串str 當成有效的表達式來求返回計算結果
num1=eval("123")
print(num1) #123
print( type(num1)) #<class 'int'>
print( eval("12+6")) #18
print( eval("12-6")) #6
print( eval("-126")) #-126
# len(srt) 返回字符串長度 就是字符個數
print( len("AAA"))
#lower() 將字符串裏面的大寫字母轉換成小寫
str6="abcFEG"
print(str6.lower()) #abcfeg
#upper() 將字符串裏面的小寫字母轉換成大寫
str9="abclktttttttttttggggggFEG"
print(str9.upper()) #ABCLKTTTTTTTTTTTGGGGGGFEG
print("AAAAAAAAAA".upper()) #AAAAAAAAAA
#swapcase() 將字符串裏面大寫字母轉小寫 小寫轉大寫
str7="AI LOVER you header"
print(str7.swapcase()) #ai lover YOU HEADER
#capitalize() 首字母大寫 其餘小寫
str0="i have you to"
print(str0.capitalize()) #I have you to
# title() 每一個單詞的首字母大寫
str2="have to nice"
print(str2.title()) #Have To Nice
# string.center(width)
# 返回一個原字符串居中,並使用空格填充至長度 width 的新字符串
#center(width,fillchar)
str77="wo ai nice lover"
print(str77.center(40,"*")) #************wo ai nice lover************
# string.ljust(width)
# 返回一個原字符串左對齊,並使用空格填充至長度 width 的新字符串
stra="wo ai nice lover"
print(stra.ljust(40,"%")) #wo ai nice lover%%%%%%%%%%%%%%%%%%%%%%%%
# string.zfill(width)
# 返回長度爲 width 的字符串，原字符串 string 右對齊，前面填充0
strb="wo ai nice lover"
print(strb.zfill(40)) #000000000000000000000000wo ai nice lover
# 返回字符串中str出現的次數 能夠指定一個範圍 默認從頭至尾
# count(str[,start][,end])
str11="wo ai nice lover and lover to hao lover"
print(str11.count("lover")) #3
print(str11.count("lover",7,len(str11))) #3
#從左到右的 第一次出現的下標數 沒有就返回-1
# string.find(str, beg=0, end=len(string))
# 檢測 str 是否包含在 string 中，若是 beg 和 end 指定範圍，
# 則檢查是否包含在指定範圍內，若是是返回開始的索引值，不然返回-1
str10="wo ai nice lover and lover to hao lover"
print(str10.find("lover")) #11
print(str10.find("ov")) #12
print(str10.find("lover",15,len(str10))) #21
# string.index(str, beg=0, end=len(string))
# 跟find()方法同樣，只不過若是str不在 string中會報一個異常.
str18="aaaAAcBBBB"
print(str18.index("A"))#3
# string.lstrip()
# 截掉 string 左邊的空格
# 默認是空格
str19=" wo ai nice lover and lover to hao lover"
print(str19.lstrip()) #wo ai nice lover and lover to hao lover
# string.rstrip()
# 截掉 string 右邊的空格
# 默認是空格
str22=" wo ai nice lover and lover to hao lover "
print(str22.strip()) #wo ai nice lover and lover to hao lover
# string.strip([obj]) 去掉左右空格
# 在 string 上執行 lstrip()和 rstrip()
str28=" pppp ai nice lover and lover to hao lover "
print(str28.strip()) #pppp ai nice lover and lover to hao lover
# Python replace()
# old（舊字符串） 替換成 new(新字符串)，若是指定第三個參數max，則替換不超過 max
str3="this is string example....wow!!! this is really string";
print (str3.replace("is", "was")); #thwas was string example....wow!!! thwas was really string
print (str3.replace("is", "was", 3));#thwas was string example....wow!!! thwas is really string
# Python isnumeric() 方法檢測字符串是否只由數字組成。這種方法是隻針對unicode對象。
# 注：定義一個字符串爲Unicode，只須要在字符串前添加 'u' 前綴便可，具體能夠查看本章節例子。
# 若是字符串中只包含數字字符，則返回 True，不然返回 False
str55 = u"this2009";
print(str55.isnumeric()); #False
str11= u"23443434";
print (str11.isnumeric()); #True
# Python join() 方法用於將序列中的元素以指定的字符鏈接生成一個新的字符串
str = "-"
seq =("a", "b", "c")
print(str.join( seq )) #a-b-c
# 以什麼分截取字符串 變成list列表
# split(str)
str55="AS-LOLSOLLS-ollll-kkk-LLLLL"
print(str55.split("-")) #['AS', 'LOLSOLLS', 'ollll', 'kkk', 'LLLLL']
str56="AS-LOLSOLLS-ollll-kkk-LLLLL-HHHHHHHHHH-000000000"
print(str56.split("-",3)) # ['AS', 'LOLSOLLS', 'ollll', 'kkk-LLLLL-HHHHHHHHHH-000000000']
# 看這個字符串裏面有多少個單詞
str57="AS-LOLSOLLS-ollll-kkk-LLLLL-HHHHHHHHHH-000000000"
aa=str57.split("-")
c=0
for x in aa:
if len(x)>0:
c+=1
print (c) # 7
# Python max() 方法返回字符串中最大的字母。
# Python min() 方法返回字符串中最小的字母。
str = "this-is-real-string-example....wow!!!";
print ("Min character: " + min(str))
# Min character: !
# 瞭解
# # Python maketrans() 方法用於建立字符映射的轉換表，對於接受兩個參數的最簡單的調用方式，
# # 第一個參數是字符串，表示須要轉換的字符，第二個參數也是字符串表示轉換的目標。
# a = "aeiou"
# b = "12345"
# trantab = maketrans(a, b)
# str = "this is string example....wow!!!"
# print (str.translate(trantab))
# 在給定的範圍內判斷是否以給定的字符串開頭 若是沒有指定範圍默認的整個字符串
str50="I have is dream"
print(str50.startswith("I")) # //True
# 在給定的範圍內判斷是否以給定的字符串結尾 若是沒有指定範圍默認的整個字符串
str51="I have is dream"
print(str51.endswith("dream")) #True
# isalpha()是判斷字符串中至少有一個字符且全部的字符都是字母返回true 不然返回fales
str56="Ihaveisdream"
print(str56.isalpha()) # True
# isipper() 英文
# 若是字符串中至少有一個字符且全部的字符都是大寫的英文字母返回 true 與false
print("SBC".isupper()) #True
print("SBb".isupper()) #False
print("SB123".isupper()) #True
print("Sa123".isupper()) #False
istitle() 方法檢測字符串中全部的單詞拼寫首字母是否爲大寫，且其餘字母爲小寫。
str = "This Is String Example...Wow!!!"
print (str.istitle()) #True
Python isspace() 方法檢測字符串是否只由空白字符組成。
若是字符串中只包含空格，則返回 True，不然返回 False.
str = " "
print (str.isspace()) #True
實例
str="""9月6日，WePhone的創始人兼開發者蘇享茂在Google+留
1下一份網帖稱，前妻翟某某向他索要1000萬人民幣和一套房產。
2因爲本身沒有1000萬又走投無路，將要所以離開人世，並在相冊中留下
3與前妻的對話截圖。9月9日，「北京時間」記者從蘇享茂家眷處獲悉，蘇享茂於9
4月7日凌晨五點左右在公司附近的住所處跳樓自殺。蘇享茂公佈的遺書內容，尚沒有獲得翟某某迴應。
59月6日，WePhone創始人兼開發者蘇享茂用GoogleIDW
6nQiangXu發帖，稱本身被惡毒前妻相逼，將要離開人世，WePhone
7之後將中止運營等信息，並附上前妻手機號碼、工做單位。此外，蘇享茂還在相冊中上傳本身與前妻的聊
8天截圖，以及兩人簽署的離婚合約。網帖稱，本身的前妻翟
9某某經過如下兩點要挾本身：
0"""
aa=str.splitlines(True)
print(aa)
十五. 格式化輸出
實例:
print("MY name is hellow jiab")
num=10
str="哈哈哈哈哈哈哈哈"
str2="17760453112"
#佔位符 %d %f %s
#轉義字符 \
print("num=%d，str=%s"%(num,str) )
十六. 布爾值和空值
# //布爾值就只有兩種: True 和 false
b1=True
b2=false
print(b1,b2)
空值:是python中一個特殊的值 用None 來表示
None 不能理解
由於；零是有意義的
而None是一個特殊值
n=Noen
print(n Noen
十七. 列表(list)
# 列表 是一種有序的集合 來存儲大量的數據
age1=32
# age2=22
# age3=45
# age4=42
# age5=49
# age6=450
# print((age1+age2+age3+age4+age5+age6)/5) #128
# 建立列表
# 格式: 列表名=[列表選項1,列表選項2,列表選項3,列表選項4,列表選項5]
# 建立一個空列表
# list1=[]
# 建立一個有元素的列表
# list2=[12,13,15,44]
# 注意: 列表中的元素數據 能夠是不一樣類型的數據
# list3=[1,2,3,"SHSHSHH","nice",True]
# print(list3)
# 列表元素的訪問
# 取值: 格式 列表名[下標]
# 注意:訪問不要越界
# list4=[1,2,3,5,6]
# print(list4[2]) #3
# 替換:
# list4=[2]=300
# print(list4) #1 2 300 6
# # 求列表中的平均值 list5=[22,23,24,25,66] index=0 sum=0 while index<5: sum+=list5[index] index+=1 if index==5: print(sum/5)
# 列表組合
# list6=[0,23,25,5]
# list7=[1,6]
# list8=list6+list7
# print(list8) #[0,23,25,5,1,6]
# 列表重複
# list9=[1,2,3]
# list10= list9*3
# print(list10) #[1,2,3,1,2,3,1,2,3]
# 判斷元素是否在列表中
# list11=[1,2,3]
# print(3 in list11) #判斷3在不在列表中 在返回 True
# # 列表截取
# list12=[4,5,6,7,8,9]
# print(list12[2:5]) # 6,7,8 截取2到5這個範圍中
# print(list12[2:]) # 6 7 8 9 截取到最後
# print(list12[:5]) # 4 5 6 7 8 截取到下標5以前的下標
# # 二維列表
# list55=[[1,9,8],[2,3,4,6] ,[2,88,6,5]]
# #8
# print(list55[1][1]) #3
# print(list55[0][1]) #9
# print(list55[2][1]) #88
# # 列表方法
# # 該方法無返回值，可是會修改原來的列表
# # 在列表末尾添加新的對象 list.append(obj)追加一個元素到末尾
# aList = [123, 'xyz', 'zara', 'abc']
# List.append( 2009 )
# print ("Updated List : ", aList) #Updated List : [123, 'xyz', 'zara', 'abc', 2009]
# list5=[5,6,9]
# list5.append(6)
# list5.append([5,6])
# print(list5) #[5,6,9,6,[5,6]]
# 追加多個元素 在末尾一次性追加一個列表中多個值
# 該方法沒有返回值，但會在已存在的列表中添加新的列表內容
# 如下實例展現了 extend()函數的使用方法：
# aList = [123, 'xyz', 'zara', 'abc', 123];
# bList = [2009, 'manni'];
# aList.extend(bList)
# print ("Extended List : ", aList ) #[123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']
# insert() 函數用於將指定對象插入列表的指定位置。
# index -- 對象 obj 須要插入的索引位置。
# obj -- 要插入列表中的對象。
# aList = [123, 'xyz', 'zara', 'abc']
# aList.insert( 3, 2009)
# print ("Final List : ", aList) #[123, 'xyz', 'zara', 2009, 'abc']
# pop() 函數用於移除列表中的一個元素（默認最後一個元素），而且返回該元素的值。
# obj -- 可選參數，要移除列表元素的索引值，不能超過列表總長度，默認爲 index=-1，刪除最後一個列表值。
# 該方法返回從列表中移除的元素對象。
# list1 = ['Google', 'Runoob', 'Taobao']
# list_pop=list1.pop(1)
# print ("刪除的項爲 :", list_pop)
# print ("列表如今爲 : ", list1)
# 刪除的項爲 : Runoob
# 列表如今爲 : ['Google', 'Taobao']
# remove() 函數用於移除列表中某個值的第一個匹配項
# obj -- 列表中要移除的對象。
# 該方法沒有返回值可是會移除列表中的某個值的第一個匹配項。
# aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
# aList.remove('xyz');
# print ("List : ", aList) # [123, 'zara', 'abc', 'xyz']
# aList.remove('abc');
# print ("List : ", aList;) #[123, 'zara', 'xyz']
# 清楚列表中全部的數據
# list99=[56,78,94,2]
# list99.clear()
# print(list99) #[]
# 從列表中找出某個值得下標 第一個匹配的索引值
# list4=[2,3,4,6,3]
# list5=list4.index(3)
# print(list5) #1
# aList = [123, 'xyz', 'zara', 'abc'];
# print "Index for xyz : ", aList.index( 'xyz' ) ; # 1
# print "Index for zara : ", aList.index( 'zara' ) #2
# 列表中元素的個數
# list66=[2,5,46,78,8]
# print(len(list66)) #5
# reverse() 函數用於反向列表中元素。
# reverse()方法語法：
# 該方法沒有返回值，可是會對列表的元素進行反向排序。
# aList = [123, 'xyz', 'zara', 'abc', 'xyz']
# aList.reverse()
# print ("List : ", aList) # ['xyz', 'abc', 'zara', 'xyz', 123]
# 獲取列表中最小的值
# list22=[78,9,4,5]
# print(min(list22)) #4
# 返回元素在列表中出現的次數
# count() 方法用於統計某個元素在列表中出現的次數。、
# 查看一個元素在列表中出現了多少次
# cont()
# list8=[1,2,3,45,2,9,66,2,8,2]
# print(list8.count(2)) #4
# 刪除列表中屢次出現的元素 # list66=[5,56,89,6,5,36,5,6,5] # all=list66.count(5) #4 # Index=0 # while Index<all： # list66.remove(5) # index+=1 # print (list66)
# sort() 函數用於對原列表進行排序，若是指定參數，則使用比較函數指定的比較函數。
# sort()方法語法：
# list.sort(cmp=None, key=None, reverse=False)
# cmp -- 可選參數, 若是指定了該參數會使用該參數的方法進行排序。
# key -- 主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可迭代對象中，指定可迭代對象中的一個元素來進行排序。
# 將元組轉換成列表
a=list((1,2,3,4))
print (a) # [1, 2, 3, 4]
# 拷貝(淺拷貝)
list2=[12,3,45,66]
list3=list2
list3[1]=200
print(list3) # [12, 200, 45, 66]
print(list2) #[12, 200, 45, 66]
print(id(list3)) # 6355144
print(id(list2)) # 6355144
# 深拷貝 內存拷貝
list30=[1,2,3,4,5]
list31=list30.copy()
list30[1]=200
print(list30) # [1, 200, 3, 4, 5]
print(list31) # [1, 2, 3, 4, 5]
print(id(list30)) # 39035784
print(id(list31)) # 39383944
# 輸出10個數字找出第二大值 # listNum=[] # num=0 # while num <5: # val=int(input("請輸入5個數:")) # listNum.append(val) # num+=1 # print (listNum) # # 升序排列 # listNum.sort() # print (listNum) # count=listNum.count(listNum[len(listNum)-1]) # c=0 # while c<count: # listNum.pop() # c+=1 # print(listNum[len(listNum)-1]) # 請輸入5個數:65 # 請輸入5個數:55 # 請輸入5個數:32 # 請輸入5個數:88 # 請輸入5個數:57 # [65, 55, 32, 88, 57] # [32, 55, 57, 65, 88] # 65 #90=2*3*3*5 num=int(input("輸入一個是因式分解")) i=2 while num!=1: if num%i==0: num//=i print("i=",i) print("num=",num) else: i+=1
十八. 繪圖模塊
# 導入繪圖模塊
# import turtle
# turtle.forward
十九. 元組
# Python的元組與列表相似，不一樣之處在於元組的元素不能修改。
# 元組使用小括號，列表使用方括號。
# 元組建立很簡單，只須要在括號中添加元素，並使用逗號隔開便可。
# 建立空元組
# tup1 = ();
# 元組中只包含一個元素時，須要在元素後面添加逗號
# tup1 = (50,);
# 元組可使用下標索引來訪問元組中的值
# 格式:元組名:下標
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print (tup1[0]) #physics
print (tup2[1:5]) #(2, 3, 4, 5)
print (tup2[-1]) #7 元組獲取最後一個元素-1 倒數是從-1開始
# 元組不能變 是指元組裏面的元素不能夠改變
# 元組中的元素值是不容許修改的，但咱們能夠對元組進行鏈接組合，以下實例:
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
# 建立一個新的元組
tup3 = tup1 + tup2;
print (tup3); #(12, 34.56, 'abc', 'xyz')
# tup6=(1,2,3,[7,8,9])
# tup6[-1][1]=1000
# print(tup6) # (1, 2, 3, [7, 1000, 9])
# 元組中的元素值是不容許刪除的，但咱們可使用del語句來刪除整個元組
# tup6=(1,2,3,[7,8,9])
# del tup6
# 元組鏈接
t1=(1,2,3)
t2=(10,25,39)
t3=t1+t2
print(t3) # (1, 2, 3, 10, 25, 39)
# 元組重複
# t1=(1,2,3)
# print(t1*3) #(1, 2, 3, 1, 2, 3, 1, 2, 3)
# # 判斷元素是否在元組裏
# t5=(1,2,3,20)
# print(20 in t5) #True
# 元組截取
# 格式 :
# 元組名:[開始下標:結束下標]
# 從開始下標 到結束下標以前
# t9 = ('physics', 'chemistry', 1997, 2000);
# tup8 = (1, 2, 3, 4, 5, 6, 7 );
# print (tup9[0]) #physics
# print (tup8[1:5]) #(2, 3, 4, 5)
# 二維元組 :就是元素爲一維元組的的元組
t0=((1,2,3),(4,5,6),(7,8,9))
print(t0[1][1]) #5
# 元組的方法
# Python 元組 len() 函數計算元組元素個數。
# tuple2 = (123, 'xyz', 'zara')
# aa=len(tuple2)
# print(aa) #3
# Python 元組 max() 函數返回元組中元素最大值。
ta=(123, 'xyz', 'zara', 'abc')
print(max(ta)) #zara
# Python 元組 tuple() 函數將列表轉換爲元組。
aList = [123, 'xyz', 'zara', 'abc'];
aTuple = tuple(aList)
print (aTuple) #(123, 'xyz', 'zara', 'abc')
# 元組的遍歷
for x in (1,2,3,4,5,6):
print(x) #123456
二十. 字典
# 字典是另外一種可變容器模型，且可存儲任意類型對象。
# 字典的每一個鍵值(key=>value)對用冒號(:)
# 分割，每一個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式以下所示
# 鍵必須是惟一的，但值則沒必要。
# 值能夠取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。
# 字典存儲數據是無序的存儲
# 一個簡單的字典實例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
# 也可如此建立字典：
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
# 元素的訪問
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(dict["Name"]) #Runoob 沒有就會報錯
print(dict.get("Name")) #Runoob 若是字典有就獲取到這個元素 沒有也不會報錯
# 添加
dict1= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict1["age"]=22
print(dict1) #{'age': 22, 'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# 修改
dict2= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict2["Class"]=10000
print(dict2) # {'Class': 10000, 'Name': 'Runoob', 'Age': 7}
# 刪除字典元素
# 能刪單一的元素也能清空字典，清空只需一項操做。
# 顯示刪除一個字典用del命令，以下實例：
dict3 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 刪除鍵 'Name'
dict.clear() # 清空字典
del dict # 刪除字典
# 字典遍歷 dict6= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} for key in dict6: print(key) # Class # Age # Name
dict4= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
for key in dict4:
print(key,dict4[key])
# Age 7
# Class First
# Name Runoob
dict7= {'Name': 'Runoob', 'Age': 22, 'Class': 'First'}
for value in dict7.values():
print(value)
# 22
# Runoob
# First
dict8= {'Name': 'Runooeeeeeb', 'Age': 22, 'Class': '哈哈哈哈哈'}
for k,v in dict8.items():
print(k,v)
# Name Runooeeeeeb
# Age 22
# Class 哈哈哈哈哈
# enumerate() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合爲一個索引序列，
# 同時列出數據和數據下標，通常用在 for 循環當中。
# enumerate(sequence, [start=0])
# 參數
# sequence -- 一個序列、迭代器或其餘支持迭代對象。
# start -- 下標起始位置。
dict10= {'Name': 'RAAAAAA', 'Age': 220000, 'Class': '哈哈哈哈AAAA哈'}
for k,v in enumerate(dict10):
print(k,v)
# 0 Age
# 1 Class
# 2 Name
字典和list列表比較
字典 :查找和插入的速度極快 不會隨着key value 增長而加慢
須要佔用大量的內存
list
查找和插入的速度隨着數據的增多而 速度會減慢
佔用空間小 浪費的內存少
# 字典是另外一種可變容器模型，且可存儲任意類型對象。
# 字典的每一個鍵值(key=>value)對用冒號(:)
# 分割，每一個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式以下所示
# 鍵必須是惟一的，但值則沒必要。
# 值能夠取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。
# 字典存儲數據是無序的存儲
# 一個簡單的字典實例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
# 也可如此建立字典： dict1 = { 'abc': 456 }; dict2 = { 'abc': 123, 98.6: 37 };
# 元素的訪問
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(dict["Name"]) #Runoob 沒有就會報錯
print(dict.get("Name")) #Runoob 若是字典有就獲取到這個元素 沒有也不會報錯
# 添加
dict1= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} dict1["age"]=22 print(dict1) #{'age': 22, 'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# 修改
dict2= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict2["Class"]=10000
print(dict2) # {'Class': 10000, 'Name': 'Runoob', 'Age': 7}
# 刪除字典元素
# 能刪單一的元素也能清空字典，清空只需一項操做。
# 顯示刪除一個字典用del命令，以下實例：
dict3 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 刪除鍵 'Name'
dict.clear() # 清空字典
del dict # 刪除字典
# 字典遍歷
dict6= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
for key in dict6:
print(key)
# Class
# Age
# Name
dict4= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
for key in dict4:
print(key,dict4[key])
# Age 7
# Class First
# Name Runoob
dict7= {'Name': 'Runoob', 'Age': 22, 'Class': 'First'}
for value in dict7.values():
print(value)
# 22
# Runoob
# First
dict8= {'Name': 'Runooeeeeeb', 'Age': 22, 'Class': '哈哈哈哈哈'}
for k,v in dict8.items():
print(k,v)
# Name Runooeeeeeb
# Age 22
# Class 哈哈哈哈哈
# enumerate() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合爲一個索引序列，
# 同時列出數據和數據下標，通常用在 for 循環當中。
# enumerate(sequence, [start=0])
# 參數
# sequence -- 一個序列、迭代器或其餘支持迭代對象。
# start -- 下標起始位置。
dict10= {'Name': 'RAAAAAA', 'Age': 220000, 'Class': '哈哈哈哈AAAA哈'}
for k,v in enumerate(dict10):
print(k,v)
# 0 Age
# 1 Class
# 2 Name
字典和list列表比較
字典 :查找和插入的速度極快 不會隨着key value 增長而加慢
須要佔用大量的內存
list
查找和插入的速度隨着數據的增多而 速度會減慢
佔用空間小 浪費的內存少
案例1 : 做業講解歌詞下一秒
dict={} #空字典
# Python splitlines() 按照行('\r', '\r\n', \n')分隔，返回一個包含各行做爲元素的列表，
# 若是參數 keepends 爲 False，不包含換行符，若是爲 True，則保留換行符。
aa=str.splitlines()
# print(aa) # 1
for bb in aa: #循環每一行
# print(bb) #2
cc=bb.split("]")
# print(cc)
# print(cc[0])
# print(len(cc))
for i in range(len(cc)-1):
# print(i)
dd=cc[i][1:]
# print(dd)
timelist=dd.split(":")
time=float(timelist[0])*60+float(timelist[1])
dict[time]=cc[-1]
print(dict)
案例2 : 做業時間一秒 :
# 時間下一秒 # 千鋒教育 [函數基礎01] # 12：23:23 timeStr=input("請輸入時分秒:") timelist=timeStr.split(":") h=int(timelist[0]) m=int(timelist[1]) s=int(timelist[2]) s+=1 if s==60: m+=1 s=0 if m==60: h+=1 m=0 if h==24: h=0 print(h,m,s)
str="[02:05.32][03:05.45][04:54.56]" str2=str.split("]") # ['[02:05.32', '[03:05.45', '[04:54.56', ''] # # # # [02:05.32 # [03:05.45 # [04:54.56 for index in str2: print(index[1:]) # 02:05.32 # 03:05.45 # 04:54.56 aa={} bb="KSKKSK" cc="卡卡卡卡" aa[bb]=cc print(aa) # {'KSKKSK': '卡卡卡卡'}
二十一. set集合
# set() 相似字典(dict) 是一組key 集合 不存儲
# 本質: 無序 和 無重複的元素的集合
# 建立:
# 建立set 須要 一個列表(list)或者元組(tuple)或者字典(dict)做爲輸入的集合
# 重複元素能夠在set中自動過濾
s1=set([1,2,3,4,5,6,7])
print(s1) #{1, 2, 3, 4, 5, 6, 7}
# 重複元素能夠在set中自動過濾
s2=set([1,2,3,4,1,2,3])
print(s2) #{1, 2, 3, 4}
s3=set((10,22,33,4,10,22,33))
print(s3) #{33, 10, 4, 22}
# set() 相似字典(dict) 是一組key 集合 不存儲
s4=set({"name":"小明","age":25,"study":"python"})
print(s4) #{'study', 'age', 'name'}
# set添加 add
s5=set([1,2,3])
s5.add(1000)
print(s5) #{1000, 1, 2, 3}
s5.add(3) #能夠添加劇復的元素 可是不會有效果
# s5.add([7,8,9]) # set 的元素不能是列表 由於列表是可變的
s5.add((7,9,6))
print(s5) # {1000, 1, 2, 3, (7, 9, 6)} 由於元組不可變全部能添加進去
# s5.add({"name":"張三"})
# print(s5) #set的元素不能是字典 由於字典是可變的
# 添加更新update
# update 插入添加整個 list tuple 字符串打亂了
s6=set([1,2,3])
s6.update([6,7,9])
print(s6) #{1, 2, 3, 6, 7, 9} 字符串打碎查入了
s7=set([1,2,3])
s7.update((45,46,47))
print(s7) #1, 2, 3, 45, 46, 47}
s8=set([1,2,3])
s8.update(("name"))
print(s8) #{1, 2, 3, 'a', 'e', 'n', 'm'}
# 刪除
s9=set([1,2,3])
s9.remove(2)
print(s9) #{1, 3}
# set是沒有索引的
# 循環遍歷
s10=set([1,2,3,4,5,6]) for i in s10: print(i) #1 2 3 4 5 6
s11=set("name") for i in s11: print(i) #n a m e
# set裏面有交集和並集
# 交集 &
str12=set([1,2,3,4,5]) str13=set([11,2,3,44,55]) a1=str12&str13 print(a1) #{2, 3} print(type(a1)) #<class 'set'>
# 並集 |
str12=set([1,2,3,4,5]) str13=set([10,2,3,6]) a2=str12|str13 print(a2) #{1, 2, 3, 4, 5, 6, 10} print(type(a2)) #<class 'set'>
數據轉換
# list ----set a1=[1,2,3,4,5,6] a2=set(a1) print(a2) #{1, 2, 3, 4, 5, 6} # tuple----set a3=(1,2,3000,4,5,600000) a4=set(a3) print(a4) #{600000, 1, 2, 4, 5, 3000} # set----list a5={1000,200,3000,400,500,} a6=list(a5) print(a6) #[400, 3000, 200, 1000, 500] #set-----tuple a7={9999,11,1000,400,20000,} a8=tuple(a7) print(a8) #(20000, 400, 1000, 11, 9999)
二十二. os 模塊
# 導入模塊
import os
# 獲取操做系統類型 nt--->windows
#max os x #蘋果操作系統
# print(os.name) # nt 表明是window模塊
# # 打印操做系統詳細信息(目前只有在liux系統和mac系統上打印)
#print(os.uanme) # windows不支持
# 獲取操做系統中的環境變量
print(os.environ)
# 獲取指定環境變量
print(os.environ.get("PROGRAMFILES"))
# 獲取當前目錄 ./
print(os.curdir) # .
# 獲取當前工做目錄 即當前python 腳本所在的目錄
print(os.getcwd()) #E:\Studypython\py2
# 返回指定目錄下的全部文件 以列表的形勢 包含文件目錄
print(os.listdir(r"E:\Studypython\py2\1"))#['01.txt', '02.txt', '03.txt', '04.txt', '05.txt']
# 建立文件目錄
# os.mkdir("Study")
# 刪除目錄
# os.rmdir("Study")
# 建立絕對目錄
# os.mkdir(r"E:\Studypython\py2\2\HHH")
# 獲取文件屬性
# print(os.stat("Study"))
# os.stat_result(st_mode=16895, st_ino=16888498602707557, st_dev=806918758,
# st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1527945156,
# st_mtime=1527945156, st_ctime=1527945156)
# 重命名
# os.rename("Study","HHH")
# 刪除普通文件
# os.remove("HHH\1.txt")
# 運行shell命令
# os.system("notepad")
# os.system("write")
# 有些方法存在os模塊裏 還有些存在於os.path
# 查看當前的絕對路徑
# prin(os.path.abspath("./HHH"))
# 拼接路徑
# 注意參數二開始不能有斜槓
p1=r"E:\Studypython\py2\HHH"
p2="name11"
print(os.path.join(p1,p2)) #E:\Studypython\py2\HHH\name11
# 拆分路徑
path2=r"E:\Studypython\py2\HHH"
print(os.path.split(path2)) #('E:\\Studypython\\py2', 'HHH')拆分就變成元組了
# 獲取擴展名
path3="D:\tx\QQLive\Log\QXMatrix_dll_14-35-26_7300.log"
print(os.path.splitext(path3))
# ('D:\tx\\QQLive\\Log\\QXMatrix_dll_14-35-26_7300', '.log')
# 判斷是否爲目錄
print(os.path.isdir(path3)) #False
# 判斷文件是否存在
print(os.path.isfile("HHH")) #False
# 判斷目錄是否存在
path6= r"F:\dbnodeloginmd5"
print(os.path.exists(path6)) # True
# 獲取文件大小
path9= r"F:\dbnodeloginmd5\login.js"
print(os.path.getsize(path9)) #1717字符
# 獲取文件目錄
path10= r"F:\dbnodeloginmd5\login.js"
print(os.path.dirname(path10)) # F:\dbnodeloginmd5
# 獲取文件名
print(os.path.basename(path10)) #login.js
返回指定路徑下的文件和文件夾列表os.listdir(path)
- 1. Python基礎(二)
- 2. python基礎二
- 3. python(二)基礎
- 4. python基礎（二）
- 5. Python基礎（二）
- 6. Python 基礎二
- 7. Python--基礎二
- 8. python 基礎二
- 9. Python基礎篇（二）
- 10. python基礎篇（二）
- 更多相關文章...
- • Kotlin 基礎語法 - Kotlin 教程
- • Scala 基礎語法 - Scala教程
- • Kotlin學習（二）基本類型
- • RxJava操作符（二）Transforming Observables
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Python基礎(二)
- 2. python基礎二
- 3. python(二)基礎
- 4. python基礎（二）
- 5. Python基礎（二）
- 6. Python 基礎二
- 7. Python--基礎二
- 8. python 基礎二
- 9. Python基礎篇（二）
- 10. python基礎篇（二）