格式化輸出

　　格式化（format）輸出中，%s代表字符串占位符，%d代表數字占位符。（python2版本中%f代表小數占位符，%d代表整數占位符。python3版本中所有數字都用%d代表占位符。）

　　例如：輸出用戶的姓名、年齡、成績

#第一種寫法
name = input("請輸入姓名：")
age = input("請輸入年齡：")
score = input("請輸入分數：")
msg = "我叫%s,今年%s,成績%s"%(name,age,score)
print(msg)

備注：年齡和分數輸入的都是數字，卻用%s，而不用%d，因為input后默認輸出為字符串類型，所以用%s

#第二種寫法
name = input("請輸入姓名：")
age = input("請輸入年齡：")
score = input("請輸入分數;")
msg = "我叫%(Name)s,今年%(Age)s,成績為%(Score)s"
    %{"Name":name,"Age":age,"Score":score}
print(msg)

備注：當代碼一行放不下時，在斷句處輸入“”加enter進入下一行。

msg = "我叫%s,今年%d歲,學習進度為2%%" %("某某某",21)
print(msg)

備注：字符串中表示百分比時用%%。

基本運算符

假設變量a=10,b=20

1.算數運算

2.比較運算

備注：!=和<>都表示不等于，平常我們用!=表示不等于。

3. 賦值運算

4.邏輯運算

　　a.邏輯運算中其優先級為()>not>and>or.

 #輸出下列結果
 print(3 > 4 or 4 < 3 and 1==1)  # F
 print(1 < 2 and 3 < 4 or 1>2 )  # T
 print(2 > 1 and 3 < 4 or 4 > 5 and 2 < 1)  # T
 print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8)  # F
 print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) # F
 print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) # F

　　b.x or y,x為真，值就是x；x為假，值就是y.

　　 x and y,x為真，值就是y；x為假，值就是x.

#輸出值
print(8 or 4)    #8
print(0 and 3)    #0
print(0 or 4 and 3 or 7 or 9 and 6)     #3

5.in和not in

用于判斷子元素是否在原字符串中：

comment = input('請輸入你的評論')
sgort = '蒼老師'
if sgort in comment:
    print('有非法字符,從新輸入')
else:
    print('評論成功')

初識編碼

　　計算機存儲，網絡傳輸，內存計算用的都是0101010101010，也就是二進制。

1.ascii碼

　　計算機最初是由美國人發明的，這套編碼系統主要顯示英文和符號。最多用八位表示一個字符（一個字節），即2**8=256，所以ascii碼最多只能表示256個符號。

2.unicode

　　隨著全球一體化的發展，很顯然ascii碼無法將全世界的文字和符號表示出來，所以就需要一種新的可以代表所有符號的編碼，于是就產生了萬國碼——unicode，其最初為16位表示一個字符，但不足以表示所有國家的符號，就升級為32位表示一個字符。而英文只需要八位就可以表示，許多歐洲國家語言16位就可以表示，亞洲國家24位就可以表示，所以unicode采用32位表示一個字符就造成了資源的浪費。為了解決這個問題，對unicode編碼進行壓縮和優化，就有了utf-8，utf-8采用最少的位數來表示一個字符。

3.GBK

　　GBK也就是國標，只能使用于某一種語言，采用16位（兩個字節）表示一個字符，其只能表示常用的大部分中文，不足以表示所有中文。

4.編碼中各單位的轉化：

　　8bit=1byte

　　1024byte=1KB

　　1024KB=1MB

　　1024MB=1G

　　......

5.str與bytes的相互轉化

　　python中，字符串在內存中是以unicode編碼存在的，保存或者網絡傳輸的時候再轉換成其他格式(比如：utf-8，gbk，gb2312，ascii...)編碼。如果不轉換就會出現亂碼，報錯。這時我們就需要編碼之間的相互轉化。

　　python3中的一大特性就是對文本和二進制數據作了更為清晰的區分，文本總是unicode，由str類型表示。二進制數據則由bytes類型表示。

#例如：
s = 'victory'
s1 = b'victory'
print(s.capitalize(),type(s))        #Victory <class 'str'>       字符串（string）類型
print(s1.capitalize(),type(s1))      #b'Victory' <class 'bytes'>     字節包（bytes）類型

　　str轉換為bytes用 str.encode("要轉換的格式")

　　bytes轉換為str用 b"XXXX".decode()

h = "apple"
h1 = h.encode("gbk")
print(h1,type(h1))   #b'apple' <class 'bytes'>
s = b"apple"
s1 = s.decode()
print(s1,type(s1))   #apple <class 'str'>

#encode() 和 decode()    括號中不加參數的時候 默認是utf-8

w = "中國"
w1 = w.encode("gbk")
print(w1,type(w1))    #b'xd6xd0xb9xfa' <class 'bytes'>
v = b'xd6xd0xb9xfa'.decode("gbk")
print(v,type(v))      #中國 <class 'str'>

基礎數據類型

1.數字（int）

數字主要用于計算，使用方法不多，主要記住一種：

#bit length() 當十進制用二進制表示時，最少使用的位數

i = 4
print(i.bit_length())

bit length

2.布爾類型（bool）

布爾類型有兩種：True、False。用于反應條件的正確與否。

bool--->int True:1 False:0

int--->bool 非0為True，0為False

同樣的bool--->str True:"True" False："False"

　　　str--->bool 非空為True ''空為False

3.字符串（str）

（1）字符串的索引

索引即下標，就是字符串組成的元素從第一個開始，初始索引為0以此類推。

s = "adFn R24kl8* -fed"
s1 = s [0]
print(s1)
s2 = s [2]
print(s2)
s3 = s [4]
print(s3,type(s3))
s4 = s [7]
print(s4,type(s4))
s5 = s [-1]
print(s5)
s6 = s [-4]
print(s6)

字符串的索引

（2）字符串的切片

切片就是通過索引（索引：索引：步長）截取字符串的一段，形成新的字符串（原則是顧首不顧尾）

s="i have a dream"
s1 = s[0:4]
print(s1)
s2 = s[2:5]
print(s2)
#截取到最后
s3 = s[3:]
print(s3)
s4 = s[:]
print(s4)
#加步長表示截取其中某些元素
s5 = s[::2]
print(s5)
s6 = s[2:7:3]
print(s6)
#倒著從后往前取,倒著取一段必須加步長-1
s7 = s[-1:-6:-1]
print(s7)
s8 = s[::-1]
print(s8)
s9 = s[6:1:-1]
print(s9)
#倒著取某些元素
s10= s[-2:-7:-2]
print(s10)

字符串的切片

（3）字符串的常用方法

s = "i have 10 Yuan，It's my all"
#capitalize()首字母大寫，其他字母小寫
print(s.capitalize())
#swapcase()大小寫字母反轉
print(s.swapcase())
#title()非字母隔開的部分,首字母大寫,其他小寫
print(s.title())
# upper  全部大寫
# lower  全部小寫      這兩個常見
print(s.upper())
print(s.lower())
#例如  登錄時遇到的驗證碼 ，不區分大小寫，編寫程序
code = "WFfs"
your_code = input("請輸入驗證碼：")
if your_code.upper() == code.upper():
    print("輸入正確")
else:print("請重新輸入")
# center()以什么居中,填充物默認空
print(s.center(40))
print(s.center(40,'*'))
# find()通過元素找索引,可以整體找,可以切片,找不到返回-1          *********這個常用
# index()通過元素找索引,可以整體找,可以切片,找不到會報錯         *********
print(s.find('a'),type(s.find('a')))
print(s.find('my'),type(s.find('my')))
print(s.find('a'))
print(s.find('a',2,16))      #切片
print(s.find('O'))         #找不到輸出  -1
print(s.index('O'))       #找不到報錯
#startswith    判斷是否以....開頭             ****
# endswith     判斷是否以....結尾             ****常用
print(s.startswith('i'))
print(s.startswith('a'))
print(s.startswith('v',4))
print(s.startswith('v',5))
#strip 去除字符串前后兩端的空格,換行符,tab鍵等        *******
# m = "      從前有座山，山上有個廟,"" 
# 廟里有個和尚     風風火火         "
print(m.strip())
print(m.lstrip())
print(m.rstrip())
#例如登錄上有時不小心多輸入了一個空格或者tab鍵，如何通過程序規避
name = input("請輸入姓名：").strip()
if name == "某某":
    print("輸入成功")
else:print("重新輸入")
#split (此處輸入分割方式，分割方式必須為字符串中存在的元素,分割后的列表中不包含該元素)  以什么分割，最終形成一個列表
# str --->list  的方法             **********這個重要
print(s.split(' '))
print(s.split('a'))
print(s.split('a',1))     #  從哪兒切片
print(s.split('a',2))    # 數字表示從第幾個該元素之前的這一段里面切片，該元素后面的不切為一個整體
#replace ()   用于替換   括號中依次填寫"要替換內容" ，"被替換內容" ，
# # 次數（該選擇要替換幾處，不填表示該字符串中要替換內容出現的總次數）       ******
s1 = '走過路過的，點關注不迷路，點關注點關注點關注'
s2 = s1.replace('點','不',2)
print(s2)
#isalnum()、isalpha()、isdigit      用于判斷變量中的組成元素  輸出為 True   False
name='sb666'
print(name.isalnum())      #字符串由字母或數字組成
print(name.isalpha())      #字符串只由字母組成
print(name.isdigit())      #字符串只由數字組成
# format的三種表達方式       格式化輸出             ************************
#第一種     必須按順序一一對應，不能改變順序
n = '我叫{},今年{},身高{}'.format('金鑫',"23",175)   #數字用字符串或者不用都不報錯
print(n)
#第二種     必須按{}中表示的順序一一對應，不能改變順序
n = '我叫{0},今年{1},身高{2},我依然叫{1}'.format('金鑫',21,175)
print(n)
#第三種      可以改變順序
n = '我叫{name},今年{age},身高{high}'.format(name = '金鑫',high=175,age=21)
print(n)

字符串常用方法

#isspace()    用于判斷一個字符串是否全部由一個或者多個空格組成
a =""
print(a.isspace())   #False
a1 = " "
print(a1.isspace())   #True
a2 = "哈哈"
print(a2.isspace())     #False

# expandtabs()默認將一個tab鍵變成8個空格，如果tab前面的字符長度不足8個，則補全8個，
# 如果tab鍵前面的字符長度超過8個不足16個則補全16個，以此類推每次補全8個。
s = "	從前有座山	，山上有個廟，
          廟里有個和尚	"
ret = s.expandtabs()     #	前面的補全
print(ret)

View Code

#join    用于以"  "這種方式將字符串從頭到尾每個元素之間進行分割或者加入其他的東西    格式為："".join(變量)
s = 'asdfghjkl'         
s1 = "*".join(s)
print(s1)

View Code

下面出現的幾種表示方法不僅適合于字符串，也適合其他的數據類型。

# count      用于計算元素出現的次數
s =  'ASDFASDFSADFS'
print(s.count('A'))
s = 'kj,fdlfjllkd*dsksjkxbf kd'
print(len(s))

通用表示方法

4.元組（tuple）

元組被稱為只讀列表，即數據可以被查詢，但不能被修改。字符串的索引和切片同樣適用于元組。

#元組不能更改,但是如果元組元素中的列表可以被更改
tu = (1,2,'屌絲',[1,2,3],(2,3,4),True)
tu[3].pop(1)
print(tu)
tu[3].append('做頭')
print(tu)

View Code

元組和列表的相互轉化

l1 = list(tu) tu1 = tuple(l)

5.列表（list）

列表相比于字符串，不僅可以儲存不同的數據類型，而且可以儲存大量數據。列表是有序的，有索引值，可切片，方便取值。

a.增

m =["《西游記》","Are you sure",110,"啷個哩個啷",True,1,123]
#append   在列表最后面增加一個元素
m.append("演員")
print(m)
#insert    在列表中的某個位置插入一個元素   格式為   插入位置的索引，插入元素
m.insert(2,"強")
print(m)
#extend    在列表的最后面增加     要加入元素中的每一個元素     數字和bool值除外
m.extend("《圣墟》")
print(m)

列表的增

b.刪

m =["《西游記》","Are you sure",110,"啷個哩個啷",True,1,123]
#pop       可索引
m.pop()       #什么都不填默認刪除最后一個
print(m)
ret =m.pop()        #有返回值
print(ret)
#remove        按照元素去刪除，括號中必須為list中的元素
m.remove("《西游記》")
print(m)
ret = m.remove(110)
print(m)           #無返回值
m.remove(1)
print(m)      #備注：元組，列表，字典中True的默認輸出為1
#clear     清空列表
m.clear()
print(m)          #輸出結果為：[]，而不是什么都沒有
#del      功能一    刪除列表
del m
print(m)
#功能二    按照索引  切片去刪除
del m[0]
print(m)
del m[1:5:2]
print(m)

列表的刪

備注：在循環一個列表時，如果刪除某些或者某類元素，容易出錯。

l1 = [111,222,333,444,555,666,777]
#逐個刪除時，會報錯，因為每刪除一個，整體就會前移，索引發生改變，通過索引直接逐個刪會報錯
for i in range(len(l1)):
    del l1[i]
print(l1)     #直接報錯 list assignment index out of range

for i in range(len(l1)-1,-1,-1):
    print(i)
    del l1[i]
print(l1)        #從后往前倒著逐個刪除就可避免或者直接用l1.clear() 清空列表

#如果只是刪除索引為奇數的元素
#方法一  del的通過切片刪除
del l1[1::2]
print(l1)
#方法二  從后往前刪，就不會因為沒刪一個而導致整體的索引發生改變
for i in range(len(l1)-1,-1,-1):
    if i % 2 == 1:
        del l1[i]
print(l1)
#方法三  換個角度思考，刪除索引為奇數的元素，那就會留下索引為偶數的元素，我們可以創建一個新列表，將索引為偶數的元素逐個的添加到新的列表中，也可以實現刪除索引為奇數元素
l2 = []
for i in range(len(l1)):
    if i % 2 == 0:
        l2.append(l1[i])
l1 = l2
print(l1)

View Code

c.改

m =["《西游記》","Are you sure",110,"啷個哩個啷",True,1,123]
#按照索引去改
m[1] ="風"
print(m)
#按照切片去改    改后加入列表中的為修改元素中的每一個元素
m[1:4]="qwertyuiop"
print(m)
m[1:5] = [123,"雨",1 ]
print(m)

列表的改

備注：按照切片修改時，是先刪除切片部分，在迭代的添加新元素。

d.查

m =["《西游記》","Are you sure",110,"啷個哩個啷",True,1,123]
#查 按切片,按索引去查
print(m[2:4])
print(m[0])

#for 循環查
for i in m:
    print(i)

列表的查

e.其他操作

n = [1,3,6,8,7,4,2,9,10]
# len   長度
print(len(n))
#count   出現次數
ret = n.count(3)
print(ret)
#index    通過元素找索引
print(n.index(9))
#sort       從小到大輸出
n.sort()
print(n)
# #sort(reverse)    從大到小輸出
n.sort(reverse=True)
print(n)
#從后往前倒著輸出
n.reverse()
print(n)

View Code

f.列表的嵌套

l1 = ['小新','egon','wusir',[99,'tiabai','ritian',1,2,3],2]

l1[1] = l1[1].capitalize()     #對列表中的某個元素首字母大寫
print(l1)

l1[1] = 'Alex'      #替換某個元素
print(l1)

print(l1[0])
print(l1[3])


l = l1[3]
l1[3][1] = l1[3][1].upper()        #對列表中嵌套的列表中的某個元素字母全部大寫
print(l1)


l1[3][0] = str(l1[3][0] + 1)    #對嵌套元素進行自加1
print(l1)

嵌套的操作

備注：通過"".join(變量)與(變量).split()可以實現列表和字符串的互相轉換。

6.字典（dict）

　　字典是python中唯一的映射類型，采用鍵值對的方式存儲數據。python對key（鍵）進行哈希函數運算，根據計算的結果決定value（值）的存儲地址，所以字典是無序存儲的，且key必須是可哈希的。可哈希表示key必須是不可變類型，如：數字，字符串，元組。

備注：可變與不可變數據類型

　　不可變數據類型：int str bool tuple

　　可變數據類型：list dict set

另外：在3.5版本之前，字典是無序的。3.6版本（包括3.6）之后，是有序的。這里的有序和無序是指print打印的結果是有序還是無序排列的。字典的存儲還是無序的。

a.增

dic = {"name":"金鑫","age":18,"sex":"male"}
#增    格式為dic["key"] = value
#有key就覆蓋，沒有key就添加。
dic["name"] ="王子"
print(dic)       #覆蓋
dic["hobby"] = "開船"
print(dic)

#setdeafult        有key不變，沒有key才添加
dic.setdefault("name")
print(dic)
dic.setdefault("name1")
print(dic)        #添加的key不存在時，默認value為：None
dic.setdefault("nmb",123456)
print(dic)
dic.setdefault("name","太乙金星")
print(dic)         #不覆蓋

字典的增

b.刪

dic = {"name":"金鑫","age":18,"sex":"male"}
#刪  pop    按照key刪除，有返回值       如果沒有key，沒有返回值但是可設置返回值
dic.pop("name")
print(dic)
ret = dic.pop("name")
print(ret)             #有返回值
ret = dic.pop("name1")
print(ret)       #沒有返回值，直接報錯
ret = dic.pop("name1","嗚啦啦")
print(ret)        #輸出為  設置的返回值"嗚啦啦"

#clear     清空字典
dic.clear()
print(dic)

#del   刪除字典，刪除鍵值對
del dic
print(dic)
del dic["name"]
print(dic)

#popitem()    隨機刪除某個鍵值對，將刪除的鍵值對以元組的形式返回
dic.popitem()
print(dic)
ret = dic.popitem()
print(ret)       #返回值為元組

字典的刪

在循環一個字典時，如果刪除某些鍵值對，可能會報錯。

#比如，刪除下列字典中含有“k”元素的鍵值對
dict = {"k1":"kobby","k2":"jodan","a3":"james","k4":"durant"}
for i in dict:
    if "k" in i:
        del dict[i]
print(dict)   #直接報錯  dictionary changed size during iteration（字典在迭代時改變大小）
#刪除某些鍵時，由于字典的鍵為可哈希的（不可變數據類型）就會導致報錯。
#我們可以將符合條件要刪除的鍵添加到一個list中，在循環逐個刪除，因為list為不可哈希的
dict = {"k1":"kobby","k2":"jodan","a3":"james","k4":"durant"}
l1 = []
for i in dict.keys():
    l1.append(i)    #['k1', 'k2', 'a3', 'k4']轉換為由字典的鍵組成的list
for p in l1:
    if "k" in p:
        del dict[p]
print(dict)       #{'a3': 'james'}

View Code

c.改

dic = {"name":"金鑫","age":18,"sex":"male"}
#改
#覆蓋式的改，   有key就覆蓋    格式為dic["key"] = value

#update      格式為：（被覆蓋添加的）.update(要覆蓋添加的)
d = {"name":"花花","high":175}
dic.update(d)      #將d所有的鍵值對覆蓋添加（相同的key覆蓋，沒有的添加）到dic中
print(dic)
print(d)

d.update(dic)       #將dic的鍵值對，覆蓋添加到d中，dic不變
print(d)
print(dic)

字典的改

d.查

dic = {"name":"金鑫","age":18,"sex":"male"}
#查
# print(dic["name"])

#get("key")    無key時，默認值為None，可設定value
value=dic.get("name")
print(value)

value1=dic.get("name1")
print(value1)        #默認為None

value2=dic.get("name2","狐貍")
print(value2)        #輸出為設定value


#for  循環查

keys = dic.keys()
print(keys,type(keys))   #輸出結果：dict_keys(['name', 'age', 'sex']) <class 'dict_keys'>

k = list(keys)
print(k,type(k))   #['name', 'age', 'sex'] <class 'list'>    字典中的鍵key轉化為list
#同樣的字典中的值value    和  鍵值對item
# values = dic.values()               items = dic.items()
# print(values)                       print(items)
# v = list(values)                    i = list(items)
# print(v) # ['金鑫', 18, 'male']     print(i)  #[('name', '金鑫'), ('age', 18), ('sex', 'male')]   元組元素的列表


for k in dic :   #dic什么都不跟   默認輸出為：鍵key
    print(k)   #name     age      sex

for k in dic.keys():
    print(k)
for v in dic.values():
    print(v,type(v))
# 金鑫 <class 'str'>
# 18 <class 'int'>
# male <class 'str'>
for i in dic.items():
    print(i)      #輸出的鍵值對為元組形式
# ('name', '金鑫')
# ('age', 18)
# ('sex', 'male')

#兩種方式循環輸出字典中的鍵值對
#第一種
for k,v in dic.items():
    print(k,v)
#第二種
for k in dic :
    print(k,dic[k])
# name 金鑫
# age 18
# sex male

字典的查

e.字典的嵌套

dic = {
    'name':'金鑫',
    'name_list':[1,2,3,'李杰'],
    1:{
        'python10':['小黑','萌哥'],
       '老男孩':{'name':'oldboy','age':56}
    }
}
#1,[1,2,3,'李杰']追加'wusir'
#2, ['小黑','萌哥'] 小黑 萌哥中間 插入一個花哥
#3, {'name':'oldboy','age':56} 添加一個鍵值對,hobby:男人

#1.
dic["name_list"].append("wusir")
print(dic)

#2.
dic[1]["python10"].insert(1,"花哥")
print(dic)

#3
dic[1]["老男孩"]["hobby"] = "男人"
print(dic)
dic[1]["老男孩"].setdefault("hobby","男人")
print(dic)

字典的嵌套

#fromkeys      Returns a new dict with keys from iterable（可迭代的） and values equal to value（值不變）
dict1 = dict.fromkeys("abc","任意值")
print(dict1)   #{'a': '任意值', 'b': '任意值', 'c': '任意值'}

dict2 = dict.fromkeys([1,2,3],[])
print(dict2)      #{1: [], 2: [], 3: []}
dict2[1].append("隨意")
print(dict2)    #{1: ['隨意'], 2: ['隨意'], 3: ['隨意']}   每一個都添加，而不是增加1這個鍵對應的值

View Code

7.集合（set）

　　集合是無序的，不重復的數據集合，它里面的元素是可哈希的（不可變類型），但是集合本身是不可哈希（所以集合做不了字典的鍵）的。

　　集合最重要的兩點：

　　1.去重：把一個列表變成集合（集合是不重復的），就自動去重了。

　　2.關系測試：兩組數據之間的交集、并集、差集等關系。

a.增

set = {"流行","古典","搖滾","嘻哈"}
#add  直接添加
set1 = set.add("民謠")
print(set)

#update  迭代的添加
set2 = set.update("爵士")
print(set)  #{'搖滾', '爵', '士', '古典', '嘻哈', '流行'}

集合的增

b.刪

set = {"流行","古典","搖滾","嘻哈"}
#remove    按元素刪除
set1 = set.remove("搖滾")
print(set)

#pop   隨機刪除   有返回值
set2 = set.pop()
print(set)
print(set2)

#clear   清空集合
set3 = set.clear()
print(set)    #set()

#del  刪除集合
del set
print(set)

集合的刪

c.查

#for循環查
set = {"流行","古典","搖滾","嘻哈"}
for i in set:
    print(i)

循環查

d.集合的其他操作

　　(1) 交集（&或者intersection）

set1 = {2,3,4,5,6}
set2 = {4,6,7,8,9}
print(set1 & set2)    #{4, 6}
print(set1.intersection(set2))    #{4, 6}

　　(2) 并集（|或者union）

set1 = {2,3,4,5,6}
set2 = {4,6,7,8,9}
print(set1 | set2)    #{2, 3, 4, 5, 6, 7, 8, 9}
print(set1.union(set2))    #{2, 3, 4, 5, 6, 7, 8, 9}

　　(3) 差集（-或者difference）

set1 = {2,3,4,5,6}
set2 = {4,6,7,8,9}
print(set1 - set2)    #{2, 3, 5}
print(set1.difference(set2))    #{2, 3, 5}
print(set2 - set1)    #{8, 9, 7}
print(set2.difference(set1))    #{8, 9, 7}

　　(4) 反交集（^或者symmetric_difference）

set1 = {2,3,4,5,6}
set2 = {4,6,7,8,9}
print(set1 ^ set2)    #{2, 3, 5, 7, 8, 9}
print(set1.symmetric_difference(set2))    #{2, 3, 5, 7, 8, 9}

　　(5) 子集(issubset)與超集(issuperset)

set1 = {2,3,5}
set2 = {2,3,4,5,6}
print(set1 < set2)  #True
print(set1.issubset(set2))   #True   兩者一樣，都是表示set1是set2子集

print(set2 > set1)    #True
print(set2.issuperset(set1))   #True    兩者一樣，都是表示set2是set1超集

e.frozenset不可變集合，讓集合變成不可變類型。

s = frozenset("jaadddfg")
print(s,type(s))   #frozenset({'a', 'j', 'g', 'd', 'f'}) <class 'frozenset'>

set={2,3,4,56}
print(frozenset(set),type(frozenset(set)))   #frozenset({56, 2, 3, 4}) <class 'frozenset'>

for循環

用戶按照順序循環可迭代對象的內容。

#輸出下列字符串中的元素
s = 'My dream is have much ...'
#第一種方法   采用while循環
count = 0
while count < len(s):
    print(s[count])
    count += 1
#第二種方法   采用for循環
for i in s:
    print(i)

View Code

range

range當做范圍列表[]，列表中的元素是數字，而且是可控的有效數字范圍。一般與for配合使用。

for i in range(1,10):      #[1,2,3,4...9]
    print(i)
for i in range(11):       # 默認從0開始
    print(i)
for i in range(1,10,2):    # [1,3,5,7,9]
    print(i)
for i in range(10,0,-1):
    print(i)
for i in range(10,-2,-1):
    print(i)

#輸出所有元素
l1 = [1,2,3,'abc',[2,3,'sir'],7]
for i in l1:
    if type(i) == list:
        for j in i:
            print(j)
    else:
        print(i)

range的使用

enumerate

enumerate：枚舉，對于一個可迭代的（iterable）/可遍歷的對象（如列表、字符串），enumerate將其組成一個索引序列，利用它可以同時獲得索引和值。起始位置默認是零，可更改。

li = ['演員','紳士','狐貍','像風一樣','方圓幾里']
for i in enumerate(li):
    print(i)     #起始默認為0，輸出為元組
    
for index,name in enumerate(li,1):
    print(index,name)    #輸出為字符串     起始位置可更改
    
for index, name in enumerate(li, 100):       
    print(index, name)

enumerate的使用

id、is和小數據池

1.id

id用于查詢內存地址

name = '本菜'
print(id(name))    #2289588520496    2289591354376    內存地址是變化的
li = [1,2,3]
print(id(li))

2.is

is用于判斷內存地址

3.小數據池概念

　　只有數字int和字符串str才有小數據池概念，其他數據類型沒有小數據池概念。

　　對于int，多個相同數字比如：count1 = 5，count2 =5，print（count1 is count2）結果為：True。在-5~256這個區間內是存在小數據池的，這個時候兩個數字在內存中的存儲占用同一個地址，可以節約內存。超出這個范圍則會占用不同的內存地址。

　　對于str,多個相同的全部由字母組成的字符串，則都是指向一個內存地址，否則占用不同的地址。

　　相同的數字與單個字母相乘比如：name ="s"*10,name2="s"*10,print(name is name2),結果為true，在20（包含20）以內也是指向一個內存地址，否則占用不同的地址。

深淺copy

1.對于賦值運算(比如：li = [1,2,3] l1 = li ), 都是共同指向同一個內存地址。

2.淺拷貝copy

import copy

l1 = ["薛之謙",3,"周杰倫",["落花",6,9,"流水"],"陳奕迅"]
l2 = copy.copy(l1)
l1.append("音樂")
print(l1,id(l1))   #['薛之謙', 3, '周杰倫', ['落花', 6, 9, '流水'], '陳奕迅', '音樂'] 1917639257800
print(l2,id(l2))   #['薛之謙', 3, '周杰倫', ['落花', 6, 9, '流水'], '陳奕迅'] 1917640477256

l3 = copy.copy(l1)
l1[3].append("音樂")
print(l1,id(l1[3])) #['薛之謙', 3, '周杰倫', ['落花', 6, 9, '流水', '音樂'], '陳奕迅'] 1796287005704
print(l3,id(l3[3])) #['薛之謙', 3, '周杰倫', ['落花', 6, 9, '流水', '音樂'], '陳奕迅'] 1796287005704

　　對于淺copy來說，第一層都是獨立的內存地址，從第二層開始，都是指向同一個內存地址，一變都變。

3.深拷貝deepcopy

import copy

l1 = ["薛之謙",3,"周杰倫",["落花",6,9,"流水"],"陳奕迅"]
l2  = copy.deepcopy(l1)
l1.append("音樂")
print(l1,id(l1))   #['薛之謙', 3, '周杰倫', ['落花', 6, 9, '流水'], '陳奕迅', '音樂'] 1858859206216
print(l2,id(l2))   #['薛之謙', 3, '周杰倫', ['落花', 6, 9, '流水'], '陳奕迅'] 1858859205512

l3 = copy.deepcopy(l1)
l1[3].append("音樂")
print(l1,id(l1[3])) #['薛之謙', 3, '周杰倫', ['落花', 6, 9, '流水', '音樂'], '陳奕迅'] 1858859207240
print(l3,id(l3[3])) #['薛之謙', 3, '周杰倫', ['落花', 6, 9, '流水'], '陳奕迅'] 1858859206344

　　對于深copy來說，兩個是完全獨立的，改變任意一個的任何元素（無論多少層），另一個絕對不改變。

作者：趙盼盼


出處：https://www.cnblogs.com/zhaopanpan/

本文版權歸作者和博客園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文連接，否則保留追究法律責任的權利。

? 關注或點個喜歡就行 ^_^

關注我

總結

以上是生活随笔為你收集整理的python基础之数据类型的全部內容，希望文章能夠幫你解決所遇到的問題。

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