Python基礎二（基礎數據類型）

時間  2019-11-13
標籤 python 基礎 數據 類型 欄目 Python 简体版
原文   原文鏈接

1、引子：python

一、爲什麼數據要分不一樣的類型：git

數據是用來表示狀態的，不一樣的狀態就應該用不一樣的類型的數據去表示api

二、數據類型：數組

　　數字app

　　字符串運維

　　列表ide

　　元組測試

　　字典編碼

　　集合spa

　　布爾

2、總體介紹：

1 、int  數字：1,2,3... 用於計算、運算

二、str  字符串： '老男孩'...   主要是少許的數據的存儲

三、bool  布爾：True和False，主要用於判斷真假。

四、list 列表：[true，1，‘alex’，{‘name’：'oldboy'},[1,2,3],(2,3,4),{'wusir'}]  列表，js裏面叫數組

儲存大量的數據，能夠放多種數據類型，因此它也叫容器類數據。例如：布爾、數字、字符串、字典、列表、元祖、集合...

五、tuple：元組，也能夠放多種數據類型，只讀列表，不能進行修改，只限制兒子級別的，元組裏面的字典能夠改。

好比一些重要文件、信息儲存在元組中，只容許別人看，不能被惡意修改。

（true，1，‘alex’，{‘name’：'oldboy'},[1,2,3],(2,3,4),{'wusir'}）

六、dict 字典：能夠儲存大量的數據，關聯型數據。並且字典的查詢速度特別快，由於它符合二分查找。

{'name':'oldboy','age':45}

七、set  集合：用戶關係型數據的交集、並集、差集、子集...  ，能夠用於列表的去重。集合中元素都是不重複的。

八、

 

3、基礎數據類型詳細介紹

一、int（bit_length()方法，該方法也不經常使用）

i.bit_length()表示將十進制轉換成二進制，所佔的最少有效位數
"""
二進制          十進制
0000 0001          1
0000 0010          2
0000 0011          3
0000 0100          4
"""
i=3
print(i.bit_length())
i=4
print(i.bit_length())

執行結果：

2
3

二、bool 布爾值

布爾值就兩種：True，False。就是反應條件的正確與否。

真   1   True。

假   0   False。    

int轉換成布爾：
int --- > bool 0 爲False 非零 爲True

print(bool(0))  值爲：False
print(bool(1))  值爲：True


布爾值轉換成數字：
bool ---> int int(True) 等於1 int(False) 等於 0
print(int(True)) 值爲：1

print(int(False))值爲：0


str轉換成布爾：空字符串是False，非空是true
str ---> bool '' False 非空字符串 True
print(bool('')) 值爲False，有空格的不叫False

 三、字符串（字符串是有索引的，索引就是它的下標。索引從後往前最後一個是-1）

s = 'python自動化運維21期'
s1 = s[0]   #經過索引找到對應的元素
print(s1)

3.一、字符串的索引和切片（切片、步長）
索引即下標，就是字符串組成的元素從第一個開始，初始索引爲0以此類推。
s = 'python自動化運維21期'
print(s[6:9])   #自動化
print(s[-1])    #-1
print(s[-2])    #-2

切片：（顧頭不顧腚）
s[起始索引：結束索引+1：步長]
print(s[:6])    #python
print(s[:6:2])  #從p開始python間隔一個輸出一個pto
print(s[:])     #輸出整個字符串  python自動化運維21期
print(s[-1:-6:-1])  #期12維運  注意：倒着取值，必須加反向步長

print(s[8:1:-1])   #化動自noht 注意：倒着取值，必須加反向步長
print(s[-1:-5:-2])  #期2

3.二、字符串經常使用方法：

* s.capitalize()  首字母大寫，其餘字母小寫
s='oldBOY'
s1=s.capitalize()
print(s1)   #Oldboy

*** s.upper()   所有轉大寫
s2=s.upper()
print(s2)    #OLDBOY

*** s.lower()  所有轉小寫
s3=s.lower()
print(s3)   #oldboy

*** s.swapcase()   大小寫反轉
s4=s.swapcase()
print(s4)   #OLDboy

* s.title()  非字母的元素隔開的每一個單詞首字母大寫
s='alex wusir*oldboy3taibai'
s5=s.title()
print(s5)    #Alex Wusir*Oldboy3Taibai

* s.center()  居中，長度本身設定，默認填充物是None，填充物就是括號裏面的
s='oldboy'
s6=s.center(30)
print(s6)   #            oldboy            

s='oldboy'
s6=s.center(30,'*')
print(s6)  #************oldboy************


* s.count  字符串中某個元素的個數
s='olodboy'
s7=s.count('o',0,5)  #切片，顧頭不顧尾
print(s7)    # 2

*** s.startswith()   s.endswith()   start...end...切片，切片都是顧頭不顧尾
s='olodboy'
s8=s.startswith('o')
print(s8)    #True


s='olodboy'
s8=s.startswith('O')
print(s8)    #False
s9=s.endswith('y')
print(s9)     #True


s10=s.startswith('ol')
print(s10)   #True


s11=s.startswith('lo',1,5)     #切片都是顧頭不顧尾
print(s11)     #True

*** s.strip()       #去除首尾的空格、製表符\t、換行符\n
s='\t自動化測試\n'    （\t是製表符，表明4個空格。\n是換行符）
print(s)       #    自動化測試

s.strip()    #不只僅能去除空格，還可使用填充物，舉例
s='oldboey'

s12=s.strip('oye')   #只有首尾包含oye元素就去掉，o,y,e是單獨的，沒有順序的，去跟字符串首尾地方去
print(s12)      #ldb

name=input('>>>').strip()       #之後input要加strip()，爲了項目

s='    oldboey    '
s13=s.lstrip()   #只去除左邊空格   
s14=s.rstrip()   #只去除右邊空格
print(s13)       #oldboey  
print(s14)      #    oldboey

***  split（str--->list至關於字符串轉換成列表，能夠設置切割次數，隔開後的數比你設置的元素多1）
s = 'oldboywusiroalex'
l = s.split()
print(l)      #['oldboywusiroalex']

s1 = 'oldboy,wusir,alex'
l = s1.split(',')
print(l)     #['oldboy', 'wusir', 'alex']

s = 'oldboywusiroalex'
l2 = s.split('o')   
print(l2)    #['', 'ldb', 'ywusir', 'alex']

s = 'oldboywusiroalex'
s15=s.split('o',1)     #設置了切割次數
print(s15)   #['', 'ldboywusiroalex']

***  join  (list---->str)將list轉換成字符串
s='olodboy'
s16='+'.join(s)
print(s16)    #o+l+o+d+b+o+y

s=['alex','wusir','taibai']
s17='_'.join(s)
print(s17)    #alex_wusir_taibai

*** replace   替換
s='abcd'
s1=s.replace('a','p')
print (s1)    #pbcd


*** find & index      find經過元素找索引，找不到返回-1；index經過元素找索引，找不到會報錯。（比較下用find比較好）
s='abcd'
s1=s.find('d')
s2=s.index('c')
print(s1)     #3
print(s2)     #2


s='abcd'
s1=s.find('m')
print(s1)    #-1


s='abcd'
s1=s.index('m')
print(s1)
報錯：

Traceback (most recent call last):
File "H:/MyProject/day02.py", line 220, in <module>
s1=s.index('m')
ValueError: substring not found

***  格式化輸出format(3種用法)  

{}至關於%，{}中間不能有空格

   第1種：

res='我今年{}歲，個人名字叫{}'.format(18,'alex')
print(res)    #我今年18歲，個人名字叫alex
第2種：
res='我今年{0}歲，個人名字叫{1},愛好{2},我依然叫{1}'.format(18,'alex','旅遊')
print(res)    #我今年18歲，個人名字叫alex,愛好旅遊,我依然叫alex

第3種：
res='{name} {age} {sex}'.format(sex='male', name='egon', age=18)
print(res)   #egon 18 male


res='我養了只小寵物{str},它的名字叫{name},今年{age}歲，天天早上都{do}'.format(name='super',age=18,do='唱歌',str='豬')
print(res)  #我養了只小寵物豬,它的名字叫super,今年18歲，天天早上都唱歌


###公共方法：列表、元祖、字符串均可以用的方法。len、count
s = 'fdsafsdagsdafjdskahdhjlsadhfkj'
print(len(s))      #30
s = 'fdsadd'
print(s.count('d'))  #3


* is系列：isalnum、isalpha、isdigit

name = 'jinxin123'
print(name.isalnum()) #字符串由字母或數字組成    #True
print(name.isalpha()) #字符串只由字母組成       #False
print(name.isdigit()) #字符串只由數字組成       #False
i = '123a'
if i.isdigit():
    i = int(i)
else:
    print("輸入有誤...")             #輸入有誤...


name = '123'
print(name.isalnum())
print(name.isdigit())
print(name.isalpha())

結果爲：

True
True
False

 

 

#!/usr/bin/env python
# -*-coding:utf-8-*-

#求12356的全部子集
s='12356'
def PowerSetsBinary(items):
    #generate all combination of N items
    N = len(items)
    #enumerate the 2**N possible combinations
    for i in range(2**N):
        combo = []
        for j in range(N):
            #test jth bit of integer i
            if(i >> j ) % 2 == 1:
                combo.append(items[j])
        yield combo
listson=[]
for i in PowerSetsBinary(s):
    listson.append(i)


end_listson=[]
# test=[]
for j in listson:
    new_str=','.join(j)
    # test.append(new_str)
    if new_str != '':
        end_listson.append(new_str)

print(len(end_listson),end_listson)
# print(len(test))
求字符串'123456'中全部可能（子集）

 執行結果：

(31, ['1', '2', '1,2', '3', '1,3', '2,3', '1,2,3', '5', '1,5', '2,5', '1,2,5', '3,5', '1,3,5', '2,3,5', '1,2,3,5', '6', '1,6', '2,6', '1,2,6', '3,6', '1,3,6', '2,3,6', '1,2,3,6', '5,6', '1,5,6', '2,5,6', '1,2,5,6', '3,5,6', '1,3,5,6', '2,3,5,6', '1,2,3,5,6'])

 四、列表（增（3種 ：append、insert、extend）、刪（pop、remove、clear、del）、查、改）

總結：在循環一個列表中，不要對列表進行刪除的動做（改變列表元素的個數的動做），會出錯。

列表也支持索引查找、切片、步長

li = [111,'alex',222,'wusir']
print(li[1])  # alex
print(li[-1])  # wusir
print(li[:2])  # [111, 'alex']
print(li[:3:2])

值爲：

alex
wusir
[111, 'alex']
[111, 222]

##增 append

l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
#增
#append 在最後追加
l.append('葫蘆')
l.append([1,2,3])
print(l)      #['老男孩', 'alex', 'wusir', 'taibai', 'ritian', '葫蘆', [1, 2, 3]]
print(l.append('好'))   #None    這個是完成追加的動做


## insert插入
l.insert(1,'景nvshen')    #按索引位置插入
print(l)             #['老男孩', '景nvshen', 'alex', 'wusir', 'taibai', 'ritian']
 

#迭代着添加  extend
l.extend('alex')
l.extend(['111',222,333])
print(l)     #['老男孩', 'alex', 'wusir', 'taibai', 'ritian', 'a', 'l', 'e', 'x', '111', 222, 333]

--------------------------------------------------------------------------------------
#刪除
 

#pop 有返回值  按照索引刪除，有返回值，刪除誰返回誰，增刪查改種惟一一個有返回值的
print(l.pop(0))     #老男孩
print(l)            #['alex', 'wusir', 'taibai', 'ritian']

 

#remove     按元素刪除
l.remove('alex')
print(l)       #['老男孩', 'wusir', 'taibai', 'ritian']

 

#clear 清空列表
l.clear()
print(l)        #[]


 

#del 內存級別刪除列表
del l
print(l)    #報錯

 

#del按索引刪除
l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
del l[1]
print(l)    #['老男孩', 'wusir', 'taibai', 'ritian']

 

#del切片刪除
 

l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
del l[:3]
print(l)    #['taibai', 'ritian']

 

# 改
#按照索引改
print(l[2])     #wusir
l[2] = '武藤蘭'
print(l)        #['老男孩', 'alex', '武藤蘭', 'taibai', 'ritian']

 

#按照切片去改  （把切片內刪除，把想添加元素最小單位添加進去）
l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
l[:2] = 'abc'
print(l)                 #['a', 'b', 'c', 'wusir', 'taibai', 'ritian']
l[1:3] = [111,222,333,444]
print(l)                 #['a', 111, 222, 333, 444, 'wusir', 'taibai', 'ritian']

 

# 查（3種）
#按照索引去查詢，按照切片去查詢，for循環查找
l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
for i in l:
    print(i)


其餘方法：
 

l1 = [1,2,1,2,1,1,3,4]

# 其餘方法：
#count 計數
print(l1.count(1))    #4
 

#len
print(len(l1))        #8
 

#經過元素找索引
l1 = [1,2,1,2,1,1,3,4]
print(l1.index(2))    #1  只找第一個出現的位置


#排序
 

l2 = [3,2,4,6,9,8,7,1]

#sort
l2.sort()  #從小到大
print(l2)   #[1, 2, 3, 4, 6, 7, 8, 9]

 

l2.sort(reverse=True)  #從大到小排序
print(l2)  #[9, 8, 7, 6, 4, 3, 2, 1]

 

#reverse         #反過來輸出
l2 = [3,2,4,6,9,8,7,1]
l2.reverse()  #[1, 7, 8, 9, 6, 4, 2, 3]

 

#列表的嵌套
l1 = [1, 2, 'alfdsafex', 'wusir',['oldboy', 'ritian', 10], 'taibai']
#1,將'alex'所有變成大寫，放回原處。
l1[2] = 'ALEX'
print(l1[2].upper())     #ALEX
l1[2] = l1[2].upper()
print(l1)               #[1, 2, 'ALEX', 'wusir', ['oldboy', 'ritian', 10], 'taibai']

 

#2.給['oldboy', 'ritian', 99] 追加一個元素‘女神’。 一個方法
l1[-2].append('女財神')
print(l1)             #[1, 2, 'ALEX', 'wusir', ['oldboy', 'ritian', 10, '女財神'], 'taibai']
 

#3，將'ritian'首字母大寫，放回原處。
l1[-2][1] = l1[-2][1].capitalize()
print(l1)            #[1, 2, 'ALEX', 'wusir', ['oldboy', 'Ritian', 10, '女財神'], 'taibai']
 

#4，將10經過數字相加，或者字符串相加或者等等，變成'100'
 

l1 = [1, 2, 'alfdsafex', 'wusir',['oldboy', 'ritian', 10], 'taibai']
 

l1[-2][-1] = str(l1[-2][-1]) + '0'
print(l1)     #[1, 2, 'alfdsafex', 'wusir', ['oldboy', 'ritian', '100'], 'taibai'] 

 

 
  
  
 
 
  
List=[1,2,2,2,2,3,3,3,4,4,4,4,'abc']
a = {}
for i in List:
  if List.count(i) >= 1:
    a[i] = List.count(i)
print (a)

執行結果：
{1: 1, 2: 4, 3: 3, 4: 4, 'abc': 1}
 
 
 
 求list中每一個元素出現的個數放到字典中 

 

 
 

五、字典（在循環字典時，不要對字典進行刪除，不要改變字典的大小）
 

'''
字典的key是惟一的。key 必須是不可變的數據類型。
    key:不可變的數據類型(可哈希)：str，bool，tuple，int。
    value：任意數據類型。
        數據類型分類：
            不可變的數據類型(可哈希)：str，bool，tuple，int
            可變的數據類型：dict，list，set。
            容器類數據類型：list，tuple，dict，set.
字典：存儲數據多，關係型數據，查詢速度快（二分查找）。
3.6版本以前，字典是無序的，3.6以後字典是有序的。
'''

#字典的增
 

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
#增
#  dic['high'] 有則覆蓋，無則添加
dic['high'] = 180
dic['name'] = 'ritian'
print(dic)    #{'name': 'ritian', 'age': 21, 'hobby': 'girl', 'high': 180}

 

# dic.setdefault() 有則不變，無則添加
dic.setdefault('high')
dic.setdefault('high',180)
dic.setdefault('name','日天')
print(dic)    #{'name': 'taibai', 'age': 21, 'hobby': 'girl', 'high': None}

 

# 刪  pop
dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
print(dic.pop('name'))  # 返回值 對應的值    #taibai
 

dic.pop('name')    字典的刪除，經過鍵刪除，刪除整個鍵值對
 


print(dic.pop('name1','沒有此key sb'))     #沒有此key sb

#clear清空字典裏面的內容
 

print(dic)
dic.clear()  # 清空
print(dic)    #{}

 

print(dic.popitem())  #隨機刪除，返回值   #('hobby', 'girl')
print(dic)                             #{'name': 'taibai', 'age': 21}

 

del dic    #內存級別的刪除
print(dic)  

 

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
del dic['age']  #根據鍵刪除
print(dic)      #{'name': 'taibai', 'hobby': 'girl'}

 

# 改
dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
dic['name'] = '老男孩'
print(dic)      #{'name': '老男孩', 'age': 21, 'hobby': 'girl'}

 

dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic)  # 將dic的鍵值對覆蓋添加到dic2中，dic不變。
print(dic)     #{'name': 'jin', 'age': 18, 'sex': 'male'}
print(dic2)     #{'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}

#查
 

dic = {"name":"jin","age":18,"sex":"male"}
print(dic['name2'])   #報錯
print(dic.get('name'))   #jin
print(dic.get('name1'))   #None
print(dic.get('name1','沒有此key，sb'))   #沒有此key，sb

 

#keys() values() items()
dic = {"name":"jin","age":18,"sex":"male"}
print(list(dic.keys()))
for i in dic.keys():
    print(i)

結果以下：
 

['name', 'age', 'sex']
name
age
sex
 

 
 

----------------------------------
 

print(dic.values())
for i in dic.values():
    print(i)

執行結果：
 

dict_values(['jin', 18, 'male'])
jin
18
male
 

----------------------------------
 

print(list(dic.items()))
for i in dic.items():
    print(i)
執行結果：
 

[('name', 'jin'), ('age', 18), ('sex', 'male')]
('name', 'jin')
('age', 18)
('sex', 'male')
 

-----------------------------
 

#分別賦值
a,b = 1,2
a,b,c = ['alex', 'wusir', 'ritain']
print(a,b,c)
a = 1
b = 5
a,b = b,a
print(a,b)

執行結果：
 

alex wusir ritain
5 1
 

 
 

for i in dic.items():
    print(i)

執行結果：
 

('name', 'jin')
('age', 18)
('sex', 'male')
 

 
 

for k,v in dic.items():
    print(k,v)

執行結果：
 

name jin
age 18
sex male
 

 
 

dic = {"name":"jin","age":18,"sex":"male"}
print(len(dic))  #3

 

#fromkeys
dic1 = dict.fromkeys('abc','張三')
dic2= dict.fromkeys([1,2,3],'李四')
print(dic1)   #{'a': '張三', 'b': '張三', 'c': '張三'}
print(dic2)   #{1: '李四', 2: '李四', 3: '李四'}


 

dic3 = dict.fromkeys('abc',[])
print(dic3)     #{'a': [], 'b': [], 'c': []}
dic3['a'].append('老男孩')
print(dic3)     #{'a': ['老男孩'], 'b': ['老男孩'], 'c': ['老男孩']}

 

#字典的嵌套

dic = {
    'name_list':['b哥', '張帝', '人帥', 'kitty'],
    '老男孩':{
        'name':'老男孩',
        'age': 46,
        'sex': 'ladyboy',
    },
}
#1,['b哥', '張帝', '人帥', 'kitty']追加一個元素，'騎兵'
dic['name_list'].append('騎兵')
print(dic)
#2，將kitty所有變成大寫。
l1 = dic['name_list']
print(l1[-1].upper())
l1[-1] = l1[-1].upper()
print(dic)
dic['name_list'][-1] = dic['name_list'][-1].upper()
print(dic)

#3，將老男孩 改爲oldboy。
dic['老男孩']['name'] = 'oldboy'
print(dic)
#，將ladyboy首字母大寫。
dic['老男孩']['sex'] = dic['老男孩']['sex'].capitalize()
print(dic)
 

執行結果爲：
 

{'name_list': ['b哥', '張帝', '人帥', 'kitty', '騎兵'], '老男孩': {'name': '老男孩', 'age': 46, 'sex': 'ladyboy'}}
騎兵
{'name_list': ['b哥', '張帝', '人帥', 'kitty', '騎兵'], '老男孩': {'name': '老男孩', 'age': 46, 'sex': 'ladyboy'}}
{'name_list': ['b哥', '張帝', '人帥', 'kitty', '騎兵'], '老男孩': {'name': '老男孩', 'age': 46, 'sex': 'ladyboy'}}
{'name_list': ['b哥', '張帝', '人帥', 'kitty', '騎兵'], '老男孩': {'name': 'oldboy', 'age': 46, 'sex': 'ladyboy'}}
{'name_list': ['b哥', '張帝', '人帥', 'kitty', '騎兵'], '老男孩': {'name': 'oldboy', 'age': 46, 'sex': 'Ladyboy'}}
 

 
 

 
 

 
  
  
 
 
  
>>> dicxx = {'a':'001', 'b':'002'}
>>> list(dicxx.keys())[list(dicxx.values()).index("001")]
'a'
 
 
 
 如何根據value值找key值 

 

 
 

六、元祖（只讀，不能進行增、刪、改，只能進行查）
 

查使用for循環
 

tu = (11,2,True,[2,3,4],'alex')
for i in tu:
    print(i)
print(tu[1]) #經過索引
print(tu[:3:2])  #切片
print(tu.index(True))   #經過元素找索引
print(tu.count(2))     #元素出現的個數
print(len(tu))
tu[-2].append(666)
print(tu)

執行結果：
 

11
2
True
[2, 3, 4]
alex
2
(11, True)
2
1
5
(11, 2, True, [2, 3, 4, 666], 'alex')
 

 
 

七、集合
 

'''
集合：
    無序，不重複的數據類型。它裏面的元素必須是可哈希的。可是集合自己是不可哈希的。
    1：關係測試。交集並集，子集，差集....
    2,去重。（列表的去重）
'''
集合的增刪查改（增（2種：add和update））
 

set1 = {1,'alex',False,(1,2,3)}
l1 = [1,1,2,2,3,3,4,5,6,6]
l2 = list(set(l1))
print(l2)   #[1, 2, 3, 4, 5, 6]

 

set1 = {'alex','wusir','ritian','egon','barry'}
#增
set1.add('666')
print(set1)   #{'ritian', 'alex', 'barry', 'wusir', 'egon', '666'}


 

# update
set1.update('abc')
print(set1)


 

#刪（remove、pop、clear、del）
set1 = {'alex','wusir','ritian','egon','barry'}

set1.remove('alex')  # 刪除一個元素
print(set1)

 

set1.pop()  # 隨機刪除一個元素
print(set1)  #{'wusir', 'barry', 'egon', 'ritian'}  該值是變化的

 

set1.clear()  # 清空集合
print(set1)   #set()

 

del set1  # 刪除集合
print(set1)

#----集合：關係測試------
 

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

#交集 &  intersectio
print(set1 & set2)      #{4, 5}
print(set1.intersection(set2))   #{4, 5}

 

#並集 |   union
print(set1 | set2)      #{1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2))   #{1, 2, 3, 4, 5, 6, 7, 8}

 

#差集  -  difference
print(set1 - set2)      #{1, 2, 3}
 

print(set2 - set1)      #{8, 6, 7}
 

print(set1.difference(set2))   #{1, 2, 3}

 

#反交集 ^ symmetric_difference
print(set1 ^ set2)                      #{1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}


------------------------------------
 

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)            #True
print(set1.issubset(set2))  # 這兩個相同，都是說明set1是set2子集。 #True

print(set2 > set1)            #True
print(set2.issuperset(set1))   #True

--------------------------------------------
不可變集合，讓集合變成不可變類型
 

s = frozenset('barry')
s1 = frozenset({4,5,6,7,8})
print(s,type(s))
print(s1,type(s1))
執行結果：
 

frozenset({'a', 'y', 'r', 'b'}) <class 'frozenset'>
frozenset({4, 5, 6, 7, 8}) <class 'frozenset'>
 

八、數據類型的補充
 

range：數字的列表範圍，可定製的數字列表、顧頭不顧尾
 

l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩']
#1
del l1[1::2]
print(l1)   #['alex', 'taibai', '老男孩']
-----------------------------------------------------
 

#再循環一個列表時，不要對列表進行刪除的動做(改變列表元素的個數動做)，會出錯
 

for i in range(len(l1)):
    print(l1)  # ['alex', 'wusir', 'taibai', 'barry', '老男孩']
#                 # ['alex', 'wusir', 'taibai', 'barry', '老男孩']
#                 # ['alex', 'taibai', 'barry', '老男孩']
#                  # ['alex', 'taibai', 'barry', '老男孩']
    print(i) # 0 1  2  3
    if i % 2 == 1:
        del l1[i]
    print(l1) # ['alex', 'wusir', 'taibai', 'barry', '老男孩']
             # ['alex', 'taibai', 'barry', '老男孩']
            # ['alex', 'taibai', 'barry']
    print(i) # 0 1
 

----------------------------------------------------
 

#range 可定製的數字列表
for i in range(10):
    print(i)

結果：
 

0
1
2
3
4
5
6
7
8
9
 

 
 

for i in range(1,10):也是顧頭不顧尾
    print(i)

輸出：
 

1
2
3
4
5
6
7
8
9
 

for i in range(1,10,2):
    print(i)
輸出：
 

1
3
5
7
9
 

 
 

for i in range(10,1,-1):
    print(i)

輸出：
 

10
9
8
7
6
5
4
3
2
 

 
 

print(range(10))  #range(0, 10)

 

l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩']
 

for i in range(len(l1)-1,-1,-1):
    if i % 2 == 1:
        del l1[i]
print(l1)     #['alex', 'taibai', '老男孩']



 

# dict 再循環字典時，不要改變字典的大小。
dic = {'k1':'v1','k2':'v2','k3':'v3','r':666}
l1 = []
for i in dic:
    if 'k' in i:
        l1.append(i)
print(l1)

結果：['k1', 'k2', 'k3']

 

for i in l1:
    del dic[i]
print(dic)  #{'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'r': 666}


 

#tu 若是元組裏面只有一個元素而且沒有逗號隔開，那麼他的數據類型與該元素一致。
tu1 = (1)
print(tu1,type(tu1))
tu2 = ('alex')
print(tu2,type(tu2))

tu3 = (['alex',1,2])
print(tu3,type(tu3))

結果：
 

1 <class 'int'>
alex <class 'str'>
['alex', 1, 2] <class 'list'>
 

 
 

九、小數據池
 

python中有小數據池的概念
 

int、str只有他們有小數據池的概念，其餘的數據類型沒有
 

 
 

# int -5 ~256 的相同的數全都指向一個內存地址，節省空間。
# str：s = 'a' * 20 之內都是同一個內存地址
    #只要字符串含有非字母元素，那就不是一個內存地址
 

 

#深淺copy
#賦值運算，它們共用一個列表
 

a = [1,2,3]
b = a
a.append(666)
print(a,b)

結果：[1, 2, 3, 666] [1, 2, 3, 666]

 

#淺copy
l1 = [1,2,3]
l2 = l1.copy()
l1.append(666)
print(l1,l2)    #[1, 2, 3, 666] [1, 2, 3]
print(id(l1),id(l2))    #5241512 5242512

 

l1 = [1,2,3,[22,33]]
l2 = l1.copy()
l1[-1].append(666)
print(l1,l2)                  #[1, 2, 3, [22, 33, 666]] [1, 2, 3, [22, 33, 666]]
print(id(l1[-1]),id(l2[-1]))  #3079824 3079824

 

#對於淺copy來講，第一層建立的是新的內存地址，而從第二層開始，
# 指向的都是同一個內存地址，因此，對於第二層以及更深的層數來講，保持一致性
 

#深copy 對於深copy來講，兩個是徹底獨立的，改變任意一個的任何元素（不管多少層），另外一個絕對不改變。
import copy
l1 = [1,2,3,[22,33]]
l2 = copy.deepcopy(l1)
l1[-1].append(666)
print(l1,l2)
print(id(l1[-1]),id(l2[-1]))

結果：
 

[1, 2, 3, [22, 33, 666]] [1, 2, 3, [22, 33]]
41402776 41403736
 

 
 

十、編碼二
 

#對於英文
s = 'laonanhai'   對於字符串來講，表現形式是這個（表現形式就是你能看到的），內部編碼是unicode
print(s,type(s))

s1 = b'laonanhai'    對於bytes來講，表現形式是這個，內部編碼方式爲非unicode（非unicode包括utf-8，gbk，gb2312等等等等，只要不是unicode就行）
print(s1,type(s1))

結果：
 

laonanhai <class 'str'>
b'laonanhai' <class 'bytes'>
 

----------------------------------------
 

#對於中文：
s = '中國'
print(s,type(s))

s1 = b'\xe4\xb8\xad\xe5\x9b\xbd'
print(s1,type(s1))
結果：
 

中國 <class 'str'>
b'\xe4\xb8\xad\xe5\x9b\xbd' <class 'bytes'>
 

 
 

-----------------------------------------------------
 

#轉化
s = 'laonanhai'
s2 = s.encode('utf-8')  #str -->bytes encode 編碼
s3 = s.encode('gbk')
print(s2,s3)

結果：b'laonanhai' b'laonanhai'
--------------------------------
 

s = 'laonanhai'
 

s2 = s.encode('utf-8')  #str -->bytes encode 編碼
s3 = s.encode('gbk')
print(s2)
print(s3)
ss = s2.decode('utf-8')  # bytes ---> str decode 解碼
print(ss)
結果：
 

b'laonanhai'b'laonanhai'laonanhai


        

            

        	





    

		

            
相關文章

            

                

                

                    

                

            


            
相關標籤/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公眾號
    

    

           歡迎關注本站公眾號,獲取更多信息

        
    




    

    




	


	







    

        聯繫我們
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程