㈠ 二級Python----組合數據類型（DAY 5）
1.集合類型概述
Python語言中的集合類型與數學中的集合概念一致，即包含0個或多個數據項的無序組合。
集合是無序組合，用大括弧{}表示，它沒有索引和位置的概念，集合中元素可以動態增加或刪除。
由於集合元素獨一無二，使用集合類型能夠過濾掉重復元素。
集合類型有4個操作符，交集&、並集|、差集-、補集^，操作邏輯與數學定義相同
集合類型有一些常用的操作函數或方法
set()函數將其他的組合數據類型變成集合類型，返回結果是一個無重復且排序任意的集合。set()函數也可以生成空集合變數。
列表類型用中括弧[]表示，也可以通過list(x)函數將集合或字元串類型轉換成列表類型。
列表屬於序列類型，所以列表類型支持序列類型對應的操作
1.序列類型有一些通用的操作符和函數
2.列表的索引
索引是列表的基本操作，用於獲得列表的一個元素。使用中括弧作為索引操作符。
可以使用遍歷循環對列表類型的元素進行遍歷操作，
基本使用方式如下
3.列表的切片
切片是列表的基本操作，用於獲得列表的一個片段，即獲得一個或多個元素。切片後的結果也是列表類型。
切片的使用方式：
切片獲取列表類型從N到M（不包含M）的元素組成新的列表。當K存在時，切片獲取列表類型從N到M（不包含M）以K為步長所對應元素組成的列表。
1.列表的操作方法
ls.append(x)僅用於在列表中增加一個元素，如果希望增加多個元素，可以使用加號+，將兩個列表合並。
可以使用Python保留字del對列表元素或片段進行刪除。
如下：
或
使用索引配合等號（=）可以對列表元素進行修改。
補：元組
Python的元組與列表類似，不同之處在於元組的元素不能修改。
元組使用小括弧()，列表使用方括弧。
元組創建很簡單，只需要在括弧中添加元素，並使用逗號隔開即可。
Python語言中的字典使用大括弧{}建立，每個元素是一個鍵值對。
使用方式：
鍵和值通過冒號連接，不同鍵值對通過逗號隔開。大括弧可以表示集合，字典類型也具有和集合類似的性質，即鍵值對之間沒有順序且不能重復。
•字典的索引
列表類型採用元素順序的位置進行索引。由於字典元素「鍵值對」中鍵是值的索引，因此，可以直接利用鍵值對關系索引元素。
利用索引和賦值 = 配合，可以對字典中每個元素進行修改。
使用大括弧可以創建字典。通過索引和賦值配合，可以向字典中增加元素。
字典類型有一些通用的操作函數
字典類型存在一些操作方法
d.keys()返回字典中的所有鍵信息，返回結果是Python的一種內部數據類型dict_keys，專用於表示字典的鍵。如果希望更好的使用返回結果，可以將其轉換為列表類型。
d.values()返回字典中的所有值信息，返回結果是Python的一種內部數據類型dict_values。如果希望更好的使用返回結果，可以將其轉換為列表類型。
d.items()返回字典中的所有鍵值對信息，返回結果是Python的一種內部數據類型dict_items。
d.get(key, default)根據鍵信息查找並返回值信息，如果key存在則返回相應值，否則返回默認值，第二個元素default可以省略，如果省略則默認值為空。
d.pop(key, default)根據鍵信息查找並取出值信息，如果key存在則返回相應值，否則返回默認值，第二個元素default可以省略，如果省略則默認值為空。相比d.get()方法，d.pop()在取出相應值後，將從字典中刪除對應的鍵值對。
d.popitem()隨機從字典中取出一個鍵值對，以元組(key,value)形式返回。取出後從字典中刪除這個鍵值對。
d.clear()刪除字典中所有鍵值對。
此外，如果希望刪除字典中某一個元素， 可以使用Python保留字del。
字典類型也支持保留字in，用來判斷一個鍵是否在字典中。如果在則返回True，否則返回False。
字典可以遍歷循環對其元素進行遍歷
for循環返回的變數名是字典的索引值。如果需要獲得鍵對應的值，可以在語句塊中通過get()方法獲得。
㈡ 5.0、python基礎數據類型
python基礎二（基礎數據類型）
一、引子
1 什麼是數據？
x=10，10是我們要存儲的數據
2 為何數據要分不同的類型
數據是用來表示狀態的，不同的狀態就應該用不同的類型的數據去表示
3 數據類型
數字 字元串 列表 元組 字典 集合
二、基礎數據類型
2.1數字int
數字主要是用於計算用的，使用方法並不是很多，就記住一種就可以：
#bit_length() 當十進制用二進製表示時，最少使用的位數
v = 11
data = v.bit_length()
print(data)
2.2布爾值bool
布爾值就兩種：True，False。就是反應條件的正確與否
真 1 True
假 0 False
2.3字元串str
2.3.1、字元串的索引與切片。
索引即下標，就是字元串組成的元素從第一個開始，初始索引為0以此類推。
a = 'ABCDEFGHIJK'
print(a[0])
print(a[3])
print(a[5])
print(a[7])
切片就是通過索引（索引：索引：步長）截取字元串的一段，形成新的字元串（原則就是顧頭不顧腚）。
a = 'ABCDEFGHIJK'
print(a[0:3])
print(a[2:5])
print(a[0:]) #默認到最後
print(a[0:-1]) # -1 是列表中最後一個元素的索引，但是要滿足顧頭不顧腚的原則，所以取不到K元素
print(a[0:5:2]) #加步長
print(a[5:0:-2]) #反向加步長
2.3.2、字元串常用方法
#captalize,swapcase,title
print(name.capitalize()) #首字母大寫
print(name.swapcase()) #大小寫翻轉
msg='egon say hi'
print(msg.title()) #每個單詞的首字母大寫
# 內同居中，總長度，空白處填充
ret2 = a1.center(20,"*")
print(ret2)
#數字元串中的元素出現的個數。
# ret3 = a1.count("a",0,4) # 可切片
# print(ret3)
a2 = "hqw\t"
#\t前面的補全
# 默認將一個tab鍵變成8個空格，如果tab前面的字元長度不足8個，則補全8個，如果tab鍵前面的字元長度超過8個不足16個則補全16個，以此類推每次補全8個。
ret4 = a2.expandtabs()
print(ret4)
a4 = "dkfjdkfasf54"
#startswith 判斷是否以...開頭
#endswith 判斷是否以...結尾
# ret4 = a4.endswith('jdk',3,6) # 顧頭不顧腚
# print(ret4) # 返回的是布爾值
# ret5 = a4.startswith("kfj",1,4)
# print(ret5)
#尋找字元串中的元素是否存在
# ret6 = a4.find("fjdk",1,6)
# print(ret6) # 返回的找到的元素的索引，如果找不到返回-1
# ret61 = a4.index("fjdk",4,6)
# print(ret61) # 返回的找到的元素的索引，找不到報錯。
#split 以什麼分割，最終形成一個列表此列表不含有這個分割的元素。
# ret9 = 'title,Tilte,atre,'.split('t')
# print(ret9)
# ret91 = 'title,Tilte,atre,'.rsplit('t',1)
# print(ret91)
#format的三種玩法 格式化輸出
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)
#strip
name='*egon**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))
#replace (替換)
replace(old, new, count)
replace('被替換的字元串','要替換的字元串',一組字元串當中替換的次數)
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))
輸出：SB say :i have one tesla,my name is alex
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',2))
輸出：SB say :i have one tesla,my name is SB
#####is系列
name='jinxin123'
print(name.isalnum()) #字元串由字母或數字組成
print(name.isalpha()) #字元串只由字母組成
print(name.isdigit()) #字元串只由數字組成
2.4元祖tuple
元組被稱為只讀列表，即數據可以被查詢，但不能被修改，所以，字元串的切片操作同樣適用於元組。例：（1，2，3）（"a","b","c"）
2.5列表list
列表是python中的基礎數據類型之一，其他語言中也有類似於列表的數據類型，比如js中叫數組，他是以[]括起來，每個元素以逗號隔開，而且他裡面可以存放各種數據類型比如：
li = [『alex』,123,Ture,(1,2,3,』wusir』),[1,2,3,』小明』,],{『name』:』alex』}]
列表相比於字元串，不僅可以儲存不同的數據類型，而且可以儲存大量數據，32位python的限制是 536870912 個元素,64位python的限制是 1152921504606846975 個元素。而且列表是有序的，有索引值，可切片，方便取值。
2.5.1、增。
li = [1,'a','b',2,3,'a']
# li.insert(0,55) #按照索引去增加
# print(li)
#
# li.append('aaa') #增加到最後
# li.append([1,2,3]) #增加到最後
# print(li)
#
# li.extend(['q,a,w']) #迭代的去增
# li.extend(['q,a,w','aaa'])
# li.extend('a')
# li.extend('abc')
# li.extend('a,b,c')
# print(li)
2.5.2、刪
# l1 = li.pop(1) #按照位置去刪除，有返回值
# print(l1)
# del li[1:3] #按照位置去刪除，也可切片刪除沒有返回值。
# print(li)
# li.remove('a') #按照元素去刪除
# print(li)
# li.clear() #清空列表
2.5.3、改
# 改
# li = [1,'a','b',2,3,'a']
# li[1] = 'dfasdfas'
# print(li)
# li[1:3] = ['a','b']
# print(li)
2.5.4、查
切片去查，或者循環去查。
2.5.5、其他操作
count（數）（方法統計某個元素在列表中出現的次數）。
a = ["q","w","q","r","t","y"]
print(a.count("q"))
index（方法用於從列表中找出某個值第一個匹配項的索引位置）
a = ["q","w","r","t","y"]
print(a.index("r"))
sort （方法用於在原位置對列表進行排序）
reverse （方法將列表中的元素反向存放）
a = [2,1,3,4,5]
a.sort()# 他沒有返回值，所以只能列印a
print(a)
a.reverse()#他也沒有返回值，所以只能列印a
print(a)
2.6字典dict。
字典是python中唯一的映射類型，採用鍵值對（key-value）的形式存儲數據。python對key進行哈希函數運算，根據計算的結果決定value的存儲地址，所以字典是無序存儲的，且key必須是可哈希的。可哈希表示key必須是不可變類型，如：數字、字元串、元組。
字典(dictionary)是除列表意外python之中最靈活的內置數據結構類型。列表是有序的對象結合，字典是無序的對象集合。兩者之間的區別在於：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。
2.6.1、增
# dic['li'] = ["a","b","c"]
# print(dic)
# setdefault 在字典中添加鍵值對，如果只有鍵那對應的值是none,但是如果原字典中存在設置的鍵值對，則他不會更改或者覆蓋。
# dic.setdefault('k','v')
# print(dic) # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
# dic.setdefault('k','v1') # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
# print(dic)
2.6.2、刪
# dic_pop = dic.pop("a",'無key默認返回值') # pop根據key刪除鍵值對，並返回對應的值，如果沒有key則返回默認返回值
# print(dic_pop)
# del dic["name"] # 沒有返回值。
# print(dic)
# dic_pop1 = dic.popitem() # 隨機刪除字典中的某個鍵值對，將刪除的鍵值對以元祖的形式返回
# print(dic_pop1) # ('name','jin')
# dic_clear = dic.clear() # 清空字典
# print(dic,dic_clear) # {} None
2.6.3、改
# 改
# dic = {"name":"jin","age":18,"sex":"male"}
# dic2 = {"name":"alex","weight":75}
# dic2.update(dic) # 將dic所有的鍵值對覆蓋添加（相同的覆蓋，沒有的添加）到dic2中
# print(dic2)
2.6.4、查
# value1 = dic["name"] # 沒有會報錯
# print(value1)
#
# value2 = dic.get("djffdsafg","默認返回值") # 沒有可以返回設定的返回值
# print(value2)
2.6.5、其他操作
# item = dic.items()
# print(item,type(item)) # dict_items([('name', 'jin'), ('sex', 'male'), ('age', 18)]) <class 'dict_items'>
# 這個類型就是dict_items類型，可迭代的
# keys = dic.keys()
# print(keys,type(keys)) # dict_keys(['sex', 'age', 'name']) <class 'dict_keys'>
# values = dic.values()
# print(values,type(values)) # dict_values(['male', 18, 'jin']) <class 'dict_values'> 同上
字典的循環
# dic = {"name":"jin","age":18,"sex":"male"}
# for key in dic:
# print(key)
# for item in dic.items():
# print(item)
# for key,value in dic.items():
# print(key,value)
三，基礎數據類型的總結
按存儲空間的佔用分（從低到高）
數字
字元串
集合：無序，即無序存索引相關信息 set() { }
元組：有序，需要存索引相關信息，不可變 ( )
列表：有序，需要存索引相關信息，可變，需要處理數據的增刪改 [ ]
字典：無序，需要存key與value映射的相關信息，可變，需要處理數據的增刪改 { }
按存值個數區分
標量／原子類型數字，字元串
容器類型列表，元組，字典
按可變不可變區分
可變列表，字典
不可變數字，字元串，元組，布爾值
按訪問順序區分
直接訪問數字
順序訪問（序列類型）字元串，列表，元組
key值訪問（映射類型）字典
四，其他（for，enumerate，range）
for循環：用戶按照順序循環可迭代對象的內容
msg = '是全國范圍內最好的'
for item in msg:
print(item)
li = ['alex','銀角','女神','egon','太白']
for i in li:
print(i)
dic = {'name':'太白','age':18,'sex':'man'}
for k,v in dic.items():
print(k,v)
enumerate：枚舉，對於一個可迭代的（iterable）/可遍歷的對象（如列表、字元串），enumerate將其組成一個索引序列，利用它可以同時獲得索引和值
li = ['alex','銀角','女神','egon','太白']
for i in enumerate(li):
print(i)
for index,name in enumerate(li,1):
print(index,name)
for index, name in enumerate(li, 100): # 起始位置默認是0，可更改
print(index, name)
range：指定范圍，生成指定數字
for i in range(1,10):
print(i)
for i in range(1,10,2): # 步長
print(i)
for i in range(10,1,-2): # 反向步長
print(i)
㈢ (2) python基本數據類型總結
布爾值bool
只有bool(0)和bool()括弧中為空才表示Fasle。bool(』0『)等表示True
序列
字元串 str 可用單引號，雙引號或者三引號表示例如'str' 或"str "或者'''str'''
其中三引號常用方式如下
在字元串前面加一個R/r 表示原始字元串
一些轉義字元（特殊的字元）
元組 tuple ( )與列表list [ ]
元組與列表在python中的唯一區別就是：元組是不可變的，列表是可變的。(元組和字元串是不可變的)
在你有一些不確定長度的相同類型隊列的時候使用列表；在你提前知道元素數量的情況下使用元組，因為元素的位置很重要。
序列可以進行加法，與整數相乘，切片操作
集合set {}和字典dict {}
集合和字典的特點是 無序，不重復
set()表示空集合
{} 表示空字典
字典是通過key訪問value{key1:value1,key2:value2}
key 不能重復,類型為int,str，tuple
value可以為任意數據
序列和集合的其他運算
㈣ python的數據類型——列表
python中列表是最常見的一種數據類型，下面我們來看看列表的基本用法吧
列表的表示：list=[ ] 用中括弧表示 或者list()
列表的作用：存儲多個數據的數據類型
列表可以存儲多種數據類型，可以存儲任何類型的數據
列表的操作
獲取列表長度len()
獲取某個元素可以使用索引，索引同字元串，從頭開始就是0開始，從末尾開始就是-1
列表索引後得到的數據類型就是該元素本身的類型
切片後獲取的數據還是列表
列表是可變類型：可以增加，修改和刪除
列表的增加
1、列表的添加：列表最後添加一個元素 append
2、在指定位置添加索引：insert
3、同時添加多個元素：extend(相當於將兩個列表合並)
列表的刪除
1、刪除指定的內容 remove（當列表中含有多個相同內容的元素，默認刪除第一個）
2、刪除指定的索引 pop
列表的修改
1、通過索引來修改
說完列表的幾種操作，下面我們來看看這些操作列印出來的結果是什麼：
none是一種數據類型，表示什麼都沒有，append得到的結果為none，remove得到的結果也是none.pop得到的結果是刪除的那個元素
㈤ Python中數據類型的判斷
Python在定義變數的時候不用指明具體的的類型，解釋器會在運行的時候會自動檢查 變數的類型，並根據需要進行隱式的類型轉化。因為Python是動態語言，所以一般情 況下是不推薦進行類型轉化的。比如"+"操作時，如果加號兩邊是數據就進行加法操 作，如果兩邊是字元串就進行字元串連接操作，如果兩邊是列表就進行合並操作，甚 至可以進行復數的運算。解釋器會在運行時根據兩邊的變數的類型調用不同的內部方法。 當加號兩邊的變數類型不一樣的時候，又不能進行類型轉化，就會拋出TypeError的異常。
通常類型判斷可用兩種方法來進行判斷：
這兩種方法有什麼區別，用哪種比較好呢？
對於內建的基本類型來說，使用tpye來檢查是沒有問題的， 可是當應用到其他場合的時候，type就顯得不可靠了。比如：當我們對Python內建類型進行擴展的時候，type返回的結果就不夠准確了。
這個時候我們就需要使用isinstance來進行類型 檢查。
object表示實例，classinfo可以是直接或間接類名、基本類型或者有它們組成的元組。
㈥ 四、 python中的數據類型——列表
列表是一種有序的集合，有點類似c裡面的數組。它的特點是，可以隨時向裡面添加或刪除其中的元素，在python中經常用來存放數據。列表的特點是中括弧，內部元素用逗號隔開。 在這個列表中，可以放進去任何元素，不論你的元素是字元串、整型、浮點型、還是布爾值、空值，包括列表什麼的，都可以放進去。 元素與元素之間，用逗號隔開。 列表會為每個元素分配序號，這個序號代表它的位置，稱為索引（index），第一個元素的位置是0，第二個元素是1，以此類推。 使用索引獲取列表中的值時，需要使用中括弧來訪問，在中括弧前面加上列表名，中括弧內部是元素的索引。 0代表第一個元素的位置，1代表第二個，-1代表倒數第一個，-2代表倒數第二個 使用 len() 函數，可以查看列表裡面有多少個元素 在python中，列表的操作是非常的靈活的，我們可以向其中添加或刪除元素。 添加使用 list.append() 函數 list.append() 函數是將元素插入到列表的末尾，當我們想在特定位置插入元素時可以使用 list.insert() 函數 list.insert() 函數接受兩個參數，第一個參數是插入位置，第二個參數是要插入的元素。 需要注意的是，在使用append和insert時，必須在前面註明要操作的列表。就像上面的例子，我們要操作classmates這個列表，所以必須寫成 classmates.append() 或 classmates.insert() ，如果不這么寫，計算機就不知道你要往哪個列表中加入元素。 沒有特殊情況的話，推薦使用append()函數添加元素，因為使用append的時候，元素默認加在列表尾部，不會造成其他元素索引值的改變。如果使用insert的話，就像上面的insert(1,'Tom')，在位置1插入'Tom'後，Tom後面所有的元素，索引值都加了一個1，列表中元素越多，受影響的程度越大，因此使用append()函數要比insert()函數更快。 刪除列表中元素的方法有三種 del後面需要用索引的方式表明要刪除的元素，也就是上面的例子，names[1]代表names中的第二個元素，使用del即可刪除 list.pop() 函數與del差不多，都是使用索引值進行刪除，只不過寫法不同。 我們可以發現，執行 names.pop(1) 後，python shell列印出了第二個元素的值，也就是我們要刪除的那個值，這是因為 pop() 這個函數，是有返回值的，有時候我們需要使用這個值，這個時候就可以用變數存起來。 這樣我們就可以通過調用a而使用剛才刪掉的元素了。 list.remove() 函數的作用是刪除第一個匹配的元素，上面的例子中，names這個列表裡面，有兩個'Bob'，remove函數只刪除了第一個'Bob'。這就是 list.remove() 函數的特點。 有時候我們想使用列表的前10個元素，或者前n個元素，這時候就應該使用列表的切片。 切片和索引類似，都是使用中括弧，區別是，索引中的中括弧裡面只有一個數，而切片不同。切片是切割列表，形成切割下來的部分形成新的列表。 切片： list[start:end:[step=1]] ，這就是切片的表達式，要求start和end兩者必須有一個，step不是可以不指定，不指定的時候默認為1。 切片該怎麼理解呢，start就是開始的位置，end就是結束的位置。切片有個特點是「取前不取後」，看上面那個例子可以發現，1作為start，3作為end，1代表第二個元素，3代表第四個元素，列表切片的時候，是不取後面的那個數字對應的元素的，也就是不取第四個元素，所以names[1:3]只取了第二個元素和第三個元素，這就是所謂的取前不取後。 再看下一個例子。 當不指定start或者end的時候，start默認為0，end默認為最後一個元素的索引值+1，因為「取前不取後」，要想取到最後一個元素，必須加個1才行。 上例中，用 len(numbers) 表示了最後一個元素的索引值，因為索引值從0開始，最後一個元素的索引值一定是列表內元素個數-1，根據「取前不取後」，在end位置上的數字應該+1，所以最後就等於 len(numbers) 了。 當不設定start和end的時候，就默認取所有的元素了。 當加入step，這個選項後，step代表步長，默認為1，設定成2的時候，就是隔一個取一個，設定成3時就是隔兩個取一個。 上例中，第一個切片，start和end均未設定，因此從第一個元素開始，隔一個取一個，得到了所有奇數位置的元素。 第二個切片，start設定為了1，因此取了所有偶數位置的元素。 3在列表中，0不在列表中，所以 3 in a 是True，而 0 in a 是False 更多關於列表的信息可以通過使用 help(list) 查看幫助文檔。㈦ Python3 & 基本數據類型（一）
Python提供的基本數據類型：數值(整型、浮點型、復數、布爾型等)、字元串、列表、元組、字典、集合等，將它們簡單分類如下：
通常被稱為整型，數值為正或者負，不帶小數點。
Python 3的整型可以當做Long類型使用，所以Python 3沒有
Python 2的Long類型。
Python 初始化的時候會自動建立一個小整數對象池，方便我們調用，避免後期重復生成！這是一個包含 262個指向整數對象的指針數組，范圍是 -5 到 256 。
Python的浮點數就是數學中的小數，類似C語言中的double。
浮點數 也就是小數，如 1.23 ， 3.14 ， -9.01 等等。但是對於很大或很小的浮點數，一般用科學計數法表示，把10用e替代， 1.23x10^9 就是 1.23e9 ，或者 12.3e8 ， 0.000012 可以寫成1.2e-5 等等。
復數 由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示，復數的實部a和虛部b都是浮點。
對 與 錯 、 0 和 1 、 正 與 反 ，都是傳統意義上的布爾類型。
但在Python語言中，布爾類型只有兩個值， True 與 False 。請注意，是英文單詞的對與錯，並且首字母要大寫。
在Python中，0、0.0、-0.0、None、空字元串「」、空元組()、空列表[]、空字典{}都被當作False，還有自定義類型，如果實現了 nonzero ()或 len ()方法且方法返回0或False，則其實例也被當作False，其他對象均為True
布爾值還可以用and、or和not運算。
1)、and 運算是 與 運算，只有所有都為 True ， and 運算的結果才是 True ;
2)、or 運算是 或 運算，只要其中有一個為 True ， or 運算結果就是 True ;
3)、not 運算是 非 運算，它是單目運算符，把 True 變成 False，False 變成 True。
例如：
由以上案例可以看出，在做四則運算的時候，明顯把 True 看做 1 ， False 看做 0 。
4）空值
空值不是布爾類型，只不過和布爾關系比較緊密。
空值是Python里一個特殊的值，用 None 表示（首字母大寫）。None不能理解為0，因為0是整數類型，而None是一個特殊的值。None也不是布爾類型，而是NoneType。
在某些特定的情況下，需要對數字的類型進行轉換。
Python提供了內置的數據類型轉換函數：
int(x) 將x轉換為一個整數。如果x是一個浮點數，則截取小數部分。
float(x) 將x轉換成一個浮點數。
complex(x) 將x轉換到一個復數，實數部分為 x，虛數部分為 0。
complex(x, y)： 將 x 和 y 轉換到一個復數，實數部分為 x，虛數部分為 y。
Python字元串即可以用單引號也可以用雙引號括起來，甚至還可以用三引號括起來，字元串是以''或""括起來的任意文本。
例如：'abc'，"xyz"等等。請注意，''或""本身只是一種表示方式，不是字元串的一部分，因此，字元串'abc'隻有a，b，c這3個字元。如果'本身也是一個字元，那就可以用""括起來，比如"I'm OK"包含的字元是I，'，m，空格，O，K這6個字元。
字元串中包括特殊字元，可以用轉義字元來標識
但是字元串裡面如果有很多字元都需要轉義，就需要加很多，為了簡化，Python還允許用r''表示''內部的字元串默認不轉義
例如：
print r'\ \' #輸出：\ \
字元串的一些常見操作
切⽚是指對操作的對象截取其中⼀部分的操作
語法：序列[開始位置下標:結束位置下標:步⻓]
a. 不包含結束位置下標對應的數據， 正負整數均可；
b. 步⻓是選取間隔，正負整數均可，默認步⻓為1。
find()：檢測某個⼦串是否包含在這個字元串中，如果在返回這個⼦串開始的位置下標，否則則返回-1。
index()：檢測某個⼦串是否包含在這個字元串中，如果在返回這個⼦串開始的位置下標，否則則報異常。
rfind()： 和find()功能相同，但查找⽅向為右側開始。
rindex()：和index()功能相同，但查找⽅向為右側開始。
count()：返回某個⼦串在字元串中出現的次數。
replace()：替換
split()：按照指定字元分割字元串。
join()：⽤⼀個字元或⼦串合並字元串，即是將多個字元串合並為⼀個新的字元串。
capitalize()：將字元串第⼀個字元轉換成⼤寫。
title()：將字元串每個單詞⾸字⺟轉換成⼤寫。
lower()：將字元串中⼤寫轉⼩寫。
upper()：將字元串中⼩寫轉⼤寫。
lstrip()：刪除字元串左側空⽩字元。
rstrip()：刪除字元串右側空⽩字元。
strip()：刪除字元串兩側空⽩字元。
ljust()：返回⼀個原字元串左對⻬,並使⽤指定字元(默認空格)填充⾄對應⻓度 的新字元串。
rjust()：返回⼀個原字元串右對⻬,並使⽤指定字元(默認空格)填充⾄對應⻓度 的新字元串，語法和
ljust()相同。
center()：返回⼀個原字元串居中對⻬,並使⽤指定字元(默認空格)填充⾄對應⻓度 的新字元串，語
法和ljust()相同。
所謂判斷即是判斷真假，返回的結果是布爾型數據類型：True 或 False。
startswith()：檢查字元串是否是以指定⼦串開頭，是則返回 True，否則返回 False。如果設置開
始和結束位置下標，則在指定范圍內檢查。
endswith()：：檢查字元串是否是以指定⼦串結尾，是則返回 True，否則返回 False。如果設置開
始和結束位置下標，則在指定范圍內檢查。
isalpha()：如果字元串⾄少有⼀個字元並且所有字元都是字⺟則返回 True, 否則返回 False。
isdigit()：如果字元串只包含數字則返回 True 否則返回 False。
isalnum()：如果字元串⾄少有⼀個字元並且所有字元都是字⺟或數字則返 回 True,否則返回
False。
㈧ python數據類型（集合）
1.集合（set）是一個無序不重復元素的序列(意思是有重復的會自動刪除,每次列印元素的位置不一定)
2.基本功能是進行成員關系測試和刪除重復元素
3.可以使用大括弧 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典
4.因為set存儲的是無序集合，所以我們沒法通過索引來訪問。訪問 set中的某個元素實際上就是判斷一個元素是否在set中。
1.創建集合
s=set()#創建一個空集合
s1={1,2,3,'a','python'}
2.刪除重復的元素
集合是一個無序不重復元素的序列(意思是有重復的會自動刪除,每次列印元素的位置不一定)
3.成員關系測試(檢測某個成員是否在集合中)
案例:從終端輸入5位數,以空格隔開,把這5位數存入列表中,剔除重復的數據,列印出來
#提示,列表轉集合,集合轉列表
a=input("請輸入5位數字:")
mylist=a.split()
print(mylist)
b=set(mylist)
c=list(b)
print(c)
4.集合常用操作
1.添加元素
2.刪除元素
3.刪除整個集合
4.獲取集合的長度
5.不支持改元素
集合操作-添加元素
格式:
集合.add(元素)
格式:
集合.update(元素)
區別:
add不能添加列表,update可以
update是將字元串中的拆分成字元進行追加
add，是當做整體追加在集合中
#案例:從終端輸入一個數字就加入集合中,然後列印,又輸入一個數字,然後列印,直到輸入-1,退出輸入
#然後列印最終的集合
ms=set()
while 1:
a=int(input("請輸入一個數字:"))
if a==-1:
break
ms.add(a)
print(ms)
print(ms)
#案例:從終端輸入一個字元串就加入集合中,然後列印,又輸入一個字元串,然後列印,直到輸入q,退出輸入
#然後列印最終的集合,字元串要分開存儲,如輸入hello,存儲的列表是{'h','e','l','0'}
ms=set()
while 1:
a=input("請輸入一個字元串:")
if a=='q':
break
ms.update(a)
print(ms)
print(ms)
集合操作-刪除元素及刪除整個集合
格式:
集合.remove(元素) # 元素如果不存在會引發KeyError
集合.discard(元素) # 元素如果不存在不發生任何事
集合.pop() # 集合元素是字元串類型時刪除隨機元素。 集合元素是其他數據類型時，刪除左邊第一個元素
del 集合名 #刪除整個集合
#案例:有集合{1,2,3,'hello','world'},刪除全部字元串,然後最左邊第一個元素
a={1,2,3,'hello','world'}
a.discard("hello")
a.discard("world")
a.pop()
print(a)
集合操作-獲取集合的長度
格式:
len(集合名)
#案例:有集合{1,2,3,4,'hello','a'},保留1個元素,其他的刪除,假如元素個數不確定
s={1,2,3,4,'hello','a'}
for i in range(len(s)-1):
s.pop()
print(s)
集合的集運算
集合的交集,並集,差集,對稱差集的運算
{1,2,3,4}交集{4,5,6,7} -->4 交集(&)
{1,2,3,4}並集{4,5,6,7} ->1,2,3,4,5,6,7 並集(|)
{1,2,3,4}差集{4,5,6,7} ->1,2,3 差集(-)
{1,2,3,4}對稱差集{4,5,6,7}->1,2,3,5,6,7 4同時出現在兩個集合中,不選它 對稱差集(^)
#案例:使用花括弧和set創建各一個集合,然後對集合進行交、並、差、對稱差運算
s={1,2,3,4,5,6}
s1=set([6,7,8,9,10])
print(s&s1)
print(s|s1)
print(s-s1)
print(s^s1)
㈨ 一文搞懂python數據類型和結構
每次python從入門到精通都是從頭開始看，做這個學習筆記主要是為了讓自己可以省去學習數據類型和結構那幾章的時間，所以「偷懶」可以促進生產力發展......
分別是： 整數型、浮點型、復數、常量、布爾型、字元串 。其中復數基本不會使用到，可以不用太關注
分別是 列表、字典、集合和元組 ，其中最常見並且工作中經常使用到的就是列表和欄位，其他兩個不常見。
02、字典
列表之外，字典可能是python中用的也比較多的數據結構了，由於字典的底層應用哈希映射，所以要求字典的所有key必須是不可變元素（可哈希對象），增刪改查操作一般都能實現O(1)復雜度，是低復雜度的必備數據結構。
03、集合
集合（set）是一個無序的不重復元素序列。
可以使用大括弧 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。
集合操作可能最常見於用於對列表去重，它的最大特性是各元素僅保留1次，底層也是應用了哈希函數，所以在集合中查找元素一般也可實現O(1)復雜度，同時集合的嵌套元素也要求是不可變類型（可哈希對象）
add：在集合中增加一個元素，如果元素已存在，則無實際操作
pop：不接受任何參數，堪稱是最神秘的操作，不同於列表的從尾端刪除、字典的指定鍵刪除，集合的pop操作看似是"隨機"刪除。但實際上是按照加入集合的先後順序，刪除"最早"加入的元素
除了與列表和字典中類似的增刪改操作外，集合還支持數學概念下的集合操作，如交集、並集、差集等。
04、元組
如果說列表、字典和集合都有其各自擅長應用場景的話，那麼元組可能是最沒有存在感的數據結構：它介面有限、功能單一，而且是不可變類型。一般而言，用元組解決的問題都可以用列表實現。但使用用元組時，更多在於暗示該序列為不可變類型。當然，當元組內嵌套子列表時實際上是可以對嵌套的子列表進行更改操作的。
https://github.com/zqkyy/py_basic_structure
有問題可以私信我，歡迎交流！
㈩ 如何利用Python語言對字典數據類型進行各種操作
第一步，聲明一個字典tree，賦值name和sale鍵，並列印字典值
第二步，添加字典鍵值對，字典是由鍵值對來構成的，聲明一個字典hudi並賦值；再次利用該字典添加一個鍵值對，然後列印添加後的值
第三步，對添加的鍵值對進行修改鍵值，獲取age這個鍵，然後重新賦值，列印修改後的結果
第四步，列印hudi字典，利用del刪除字典color鍵值對，然後列印刪除後的結果
第五步，再次列印hudi字典，利用clear()方法刪除該字典所有的鍵值對
第六步，利用pop()方法對字典鍵值對進行刪除，會先列印出刪除的鍵值對！