天天看點
傳回

python字元串,集合,清單,元組,字典一.字元串字元串運算及操作二.清單四.字典五.集合

一.字元串

字元串是Pyhton中最常見的資料類型。我們可以使用引号（‘或“)來建立字元串。事實上,在pyhton中,加了引号的字元都被認為是字元串

python中單個字元和多個字元用引号包裹後,統稱為字元串,沒有java或者C中字元的說法

name = "騷姐姐"
age = "18"
age_1 = 18
msg = '''I'm Tang you''' #單引号會就近重合，使用三個單引号會避免 三單引号三雙引号可以換行使用
msg = """I'm Tang you"""
print(type(name),type(age),type(age_1),type(msg))

<class 'str'> <class 'str'> <class 'int'> <class 'str'>

字元串運算及操作

數字可以進行加減乘除等運算,字元串呢？讓我告訴你,也能?what?是的,但隻能進行"相加"和"相乘"運算

1拼接

>>>a="hello"
>>>b="pyhton"
>>>a+b
'helloPython'

注意,字元串的拼接隻能是雙方都是字元串,不能跟數字或其他類型拼接

>>>age_1=5000
>>>name+age_1
Traceback(most recent call last):
  File"<stdin>",line 1,in<module>
TypeError: must be str,not

2.重複(*)

a="hello"
print(a*5)

3.切片和索引

>>> a="Life is short,I use python"
>>> len(a)
26
>>>
>>> a[0]#索引
'L'
>>> a[16]
'u'
>>> a[-4]
't'
......
>>> a[:15]#切片
'Life is short,I'
>>> a[15:2]
''
>>> a[15::2]
' s yhn'
>>> a[::-1]
'nohtyp esu I,trohs si efiL'
>>>

4.大小寫轉換

str.lower():轉小寫
 str.upper():轉大寫
 str.swapcase():大小寫對換
 str.capltalize():字元串首為大寫,其餘小寫
 str.title():以分隔符為标記,首字元為大寫,其餘為小寫
 舉例:>>>a="life is short,I use python"
>>>a.lower()#将所有大寫字元轉換為小寫字元
'life is short,i use python'
>>>a.upper()#将所有小寫字元轉換為大寫字元
'LIFE IS SHORT,I USE PYTHON'
>>>a.swapcase()#将所有小寫字元變成打成,将大寫字元變成小寫
'lIFE IS SHORT, i USE PYTHON'
>>>a.capltalize()#将字元串的第一個字元大寫
'Life is short, i use python'
>>>a.title()#傳回标題化的字元串
'Life Is Short, I Use Python'

5.字元串格式輸出對齊

str.center()居中
 a="Life is my love"
a.center(35,"*")
'**********Life is my love**********' #傳回一個原字元串居中,并使用空格填充至長度width的新字元串
str.ljust()左對齊
>>> a.ljust(35,"*")
'Life is my love********************'
#傳回一個原字元左對齊,并使用空格填充至長度width的新字元串
 str.rjust()右對齊
    >>> a="Life is short,I use python"
>>> a.rjust(35,"*")
'*********Life is short,I use python'#傳回一個原字元串右對齊，并使用空格填充至長度width的新字元串
 str.zfill()
    >>>a.zfill(35)#傳回長度為width的字元串,原字元串string右對齊,前面填充0,隻有一個參數
'000000000Life is short,I use python'

6.删除指定字元

str.lstrip()删除左邊空格
 a="****life isshort, I use python****" #删除左邊指定字元串
>>> a.lstrip("*")
str.rstrip()删除右邊空格
'life isshort, I use python****' #删除右邊指定字元串
>>> a.rstrip("*")
str.stri()删除所有空格
>>> a.strip("*")
'life isshort, I use python'

7.計數

EXCEL表中:

計數=countif(B2:B31,">=30")/count(B2:B31)

8.字元串搜尋定位與替換

str.find()
>>> a="Life is short,I use python"
>>> a.find("e")#查找元素并傳回第一個出現的索引值
3
>>> a.find("e",18,24)
18
>>> a.find("w")
-1
>>>
str.index()和find()方法一樣,隻不過如果str不在string中會報一個異常。
>> a="Life is short,I use python"
>>> a.index("e")
3
>>> a.index("e",18)
18
>>>a.index("w")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>>
str.rindex()和index方法一樣,但是從右邊開始
str.replace()>>> a="Life is short,I use python"
>>> a.replace("I use","You need")
'Life is short,You need python'
>>> a.replace("t","T")
'Life is shorT,I use pyThon'
>>> a.replace("t","T",1)
'Life is shorT,I use python'

9.字元串條件判斷

isalnum()，字元串由字母或數字組成，
isalpha()，字元串隻由字母組成，
isdigit()，字元串隻由數字組成
           
In [1]: a = "abc123"

In [2]: b = "ABC"

In [3]: c = 123

In [4]: a.isalnum()
Out[4]: True

In [5]: a.isalpha()
Out[5]: False

In [6]: a.isdigit()
Out[6]: False

In [7]: b.isalnum()
Out[7]: True

In [8]: b.isalpha()
Out[8]: True

In [9]: b.isdigit()
Out[9]: False>>> str = '01234'
 
>>> str.isalnum()   # 是否全是字母和數字，并至少有一個字元
True
>>> str.isdigit()    # 是否全是數字，并至少有一個字元
True      
 
 
>>> str = 'string'
 
>>> str.isalnum()  # 是否全是字母和數字，并至少有一個字元
True
>>> str.isalpha()  # 是否全是字母，并至少有一個字元 
True
>>> str.islower() # 是否全是小寫，當全是小寫和數字一起時候，也判斷為True
True
 
>>> str = "01234abcd"
 
>>> str.islower() # 是否全是小寫，當全是小寫和數字一起時候，也判斷為True
True
 
>>> str.isalnum()  # 是否全是字母和數字，并至少有一個字元
True
 
>>> str = ' '
>>> str.isspace()  # 是否全是空白字元，并至少有一個字元
True
 
>>> str = 'ABC'
 
>>> str.isupper()   # 是否全是大寫，當全是大寫和數字一起時候，也判斷為True
True
 
>>> str = 'Aaa Bbb'
 
>>> str.istitle()  # 所有單詞字首都是大寫，标題 
True
 
 
>>> str = 'string learn'
 
>>> str.startswith('str') # 判斷字元串以'str'開頭
True
 
>>> str.endswith('arn')  # 判讀字元串以'arn'結尾
True

10.制表符轉化

str.expandtabs()
>>> a = "L\tife is short, I use python"
>>> a.expandtabs() # 預設将制表符轉化為8個空格
'L       ife is short, I use python'
>>> a.expandtabs(4) # 加上參數，将制表符轉化為對應個數的空格
'L   ife is short, I use pythons
>>>
  1. 011ASCII碼和字元的轉化 
chr():用一個範圍在range(256)内的(就是0~255)整數作參數，傳回一個對應的字元。
ord():将一個ASCII字元轉換為對應的數字
chr(65)
\#結果：'A'
ord('a')
\#結果：97

12字元串分割變換

join()将指定字元插入到元素之間;
#join
>>> str="learn string"
>>> "-".join(str)
'l-e-a-r-n- -s-t-r-i-n-g'
>>> "+".join(str)
'l+e+a+r+n+ +s+t+r+i+n+g'
>>> "*".join(str)
'l*e*a*r*n* *s*t*r*i*n*g'
split()以指定字元分隔序列去除該字元
#split
>>> str.split("n")
['lear', ' stri', 'g']
>>> str.split("n",1)
['lear', ' string']
>>> str.rsplit("n",1)
['learn stri', 'g']
>>> str.splitlines()
['learn string']
 partition()以指定字元串分隔序列且包含該字元
>>> str.partition("n")
('lear', 'n', ' string')
>>> str.rpartition("n")
('learn stri', 'n', 'g')

補充:

string子產品 

>>> import string
>>> dir(string)
['Formatter', 'Template', '_ChainMap', '_TemplateMetaclass', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_re', '_string', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace']
>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.capwords("hUNAN yingxiao college")
'Hunan Yingxiao College'
>>>

string子產品中的capwords()函數功能: 

1.将每個單詞首寫字母置為大寫
2.将每個單詞除首字母外的字母均置為小寫
3.将詞語詞之間的多個空格用一個空格代替
4.其擁有兩個參數,第二個參數用以判斷單詞之間的分割符,預設為空格
           
>>> string.digits
'0123456789'
>>> string.hexdigits
'0123456789abcdefABCDEF'
>>> string.octdigits
'01234567'
>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'
>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
>>>

二.清單

清單是python中的基礎資料類型之一，其他語言中也有類似于清單的資料類型，比如js中叫數組，他是以[]括起來，每個元素以逗号隔開，而且他裡面可以存放各種資料類型比如：

li = [‘ex’,123,Ture,(1,2,3,’sir’),[1,2,3,’小明’,],{‘name’:’ex’}]

清單相比于字元串，不僅可以儲存不同的資料類型，而且可以儲存大量資料，32位python的限制是 536870912 個元素,64位python的限制是 1152921504606846975 個元素。而且清單是有序的，有索引值，可切片，友善取值。

特點:是一個有序的可以重複的序列可變類型

1.建立一個空清單。

list1=[]
print(type(list1))

2.建立一個有多個值的清單,每個值用逗号隔開

list1=[17,25,16,22,28]

清單也可以存放不同類型的元素

lst2=[17,"str",[16,22,28],(66,67),{'name':'Tom','age'：18}]

清單索引和切片

lst2=[17,"str",[16,22,28],(66,67),{'name':'Tom','age'：18}]
len(lst2)
lst2[0]
18
lst2[3]
(66,67)
lst2[-1]
{'name':'tom','age':18}
lst2[3:]
[(66,67),{'name:'Tom','age':18}]
lst2[0::2]
[18,[1,2,3],{'name':'Tom','age':18}]

清單的常見操作

清單:name=['a','b','c','d']

1.增加

append():增加到最後
names=['a','b','c','d']
names.append('e')
print(names)
['a', 'b', 'c', 'd', 'e']
names=['a','b','c','d']
names.append([1,2,3])
print(names)
['a', 'b', 'c', 'd', [1, 2, 3]]
extend():疊代的去增
names=['a','b','c','d']
place=['hunan','guangdong','guangxi']
names.extend(place)
print(names)
['a', 'b', 'c', 'd', 'hunan', 'guangdong', 'guangxi']
insert()：按照索引去增加
names=['a','b','c','d']
names.insert(2,'devilf')
print(names)
['a', 'b', 'devilf', 'c', 'd']
其他的插入方法:
names=[3]
names[0]='lebron'
print(names)
['lebron']

2删除

pop()
names=['a','b','c','d']
names.pop()  #如果沒有指定下标,則預設删除最後一個元素
print(names)
names=['a','b','c','d']
names.pop(2)  #指定索引時就會删除索引所對應元素
print(names)
names=['a','b','c','d']
names
print(names)
['a', 'b', 'c']
['a', 'b', 'd']
['a', 'b', 'c', 'd']
remove():按照元素删除
names=['a','b','c','d','e','f','e']
names.remove('e')
print(names)
['a', 'b', 'c', 'd', 'f', 'e']
del():
names=['a','b','c','d','e','f','e']
del names[4]
print(names)
['a', 'b', 'c', 'd', 'f', 'e']
clear():
names = ['a', 'b', 'c', 'd', 'e', 'f', 'e']
names.clear()
print(names)
[]

3改

li=['a','b','c','d']
li[1]='cc'
print(li)
['a', 'cc', 'c', 'd']
li=['a','cc','c','d']
li[0:2]=['aa','bb']
print(li)0
['aa', 'bb', 'c', 'd']

4.查

切片查,或者，循環去查 
索引,切片，周遊
1.查找元素所在位置:index()
2.周遊
三種:
(1)
li=["python","java","C++"]
for  i in li:
print(i ,end= " ")
python java C++   
（2）
for i in range(len(li)):
print(li[i], end=" ")
python java C++
(3)
li = ["python", "java", "C++"]
for i,li[i] in enumerate(li):
print(i,li[i])
0 python
1 java
2 C++

5.其他操作

1.統計元素的次數:count()

>>> names=['a','b','c','d']
>>> names.append('d')
>>> names.count('d')
2

2.反轉:reverse()

>>> names=['a','b','c','d']
>>> names.reverse()
>>> names
['d', 'c', 'b', 'a']
>>>

3.排序:sort()按照ascii碼來進行排序

>>> names=['a','b','c','d']
>>> names.insert(3,'&&')
>>> names
['a', 'b', 'c', '&&', 'd']
>>> names.sort()
>>> names
['&&', 'a', 'b', 'c', 'd']
>>> names.sort(reverse=True)
>>> names
['d', 'c', 'b', 'a', '&&']
>>> names[::-1]
['&&', 'a', 'b', 'c', 'd']
>>>

Python字元串格式化

盡管已經掌握了所介紹的字元串方法和序列操作，Python還提供了一種更進階的方法來組合字元串處理任務——字元串格式化允許在一個單個的步驟中對一個字元串執行多個特定類型的替換。它不是嚴格必須的，但它很友善使用，特别是當格式化文本以顯示給程式的使用者的時候。由于Python世界中充滿了很多新思想，如今的Python中的字元串格式化可以以兩種形式實作：

字元串格式化表達式
  這是從Python誕生的時候就有的最初的技術；這是基于C語言的“printf”模型，并且在大多數現有的代碼中使用。
 字元串格式化方法調用
  這是Python2.6和Python3.0新增加的技術，這是Python獨有的方法，并且和字元串格式化表達式的功能有很大重疊。
      Python在對字元串操作的時候定義了%二進制操作符（你可能還記得它在對數字應用時，是除法取餘數的操作符）。當應用在字元串上的時候，%提供了簡單的方法對字元串的值進行格式化，這一操作取決于格式化定義的字元串。簡而言之，%操作符為編寫多字元串替換提供了一種簡潔的方法，而不是建構并組合單個的部分。
   格式化字元串、
1.在%操作符的左側放置一個需要進行格式化的字元串，這個字元串帶有一個或多個嵌入的轉換目标，都以%開頭（例如，%d）。
2.在%操作符右側放置一個（或多個，嵌入到元組中）對象，這些對象将會插入到左側想讓Python進行格式化字元串的一個（或多個）轉換目标的位置上去。

例如，在下列一個格式化示例中，整數1替換在格式化字元串左邊的%d，字元串‘bird’替換%s。結果就得到了一個新的字元串，這個字元串就是這兩個替換的結果：

print("No. %d:\tI'm a little little %s." % (1, "bird"))
No. 1:  I'm a little little bird.

從技術上來講，字元串的格式化表達式往往是可選的一—通常你可以使用多次的多字元串的合并和轉換達到類似的目的。然而格式化允許我們将多個步驟合并為一個簡單的操作，這一功能相當強大，我們多舉幾個例子來看一看：

>>> say = "Hello"
>>> "Hello - %s" % say
'Hello - Hello'
>>> "%d %s %d %s" % (2, "hand", 2, "eye")
'2 hand 2 eye'
>>> "%s -- %s -- %s" % (3.14, 'pi', '山巅一寺一壺酒')
'3.14 -- pi -- 山巅一寺一壺酒'
>>>　
           
在第一個例子中，在左側目标位置插入字元串"Hello"，代替标記%s。在第二個例子中，在目标字元串中插入三個值。需要注意的是當不止一個值待插入的時候，應該在右側用括号把它們括起來（也就是說，把它們放到元組中去）。%格式化表達式操作符在其右邊期待一個單獨的項或者一個或多個項的元組。
　　第三個例子同樣是插入三個值：一個整數、一個浮點數對象和一個清單對象。但是注意到所有目标左側都是%s，這就表示要把它們轉換為字元串。由于對象的每個類型都可以轉換為字元串（列印時所使用的），每一個與%s一同參與操作的對象類型都可以轉換代碼。正因如此，除非你要做特殊的格式化，一般你隻需要記得用%s這個代碼來格式化表達式。
　　另外，請記住格式化總是會傳回新的字元串作為結果而不是對左側的字元串進行修改；

由于字元串是不可變的，是以隻能這樣操作。如前所述，如果需要的話，你可以配置設定一個變量名來儲存結果。
           
表：字元串格式化代碼
代碼 意義
s 字元串（或任何對象）
r s，但使用repr，而不是str
c 字元
d 十進制（整數）i整數
u 無号（整數）八進位整數
o 八進制整數
x 十六進制整數
X x，但列印大寫
e 浮點指數
E e，但列印大寫
f 浮點十進制
F 浮點十進制
g 浮點e或f
G 浮點E或f
% 常量%

Fromat格式化(比對花括号({}))

位置映射

str="{}唱歌好聽，\n {}唱歌更好聽".format("蔣新衡","吳振")
print(str)
str="{}---{}---{}".format("wz","jxh","wyf")
print(str)
蔣新衡唱歌好聽，
 吳振唱歌更好聽
wz---jxh---wyf

關鍵字映射

str="{0}---{name}---{1}".format("wz","jxh",name="wyf")
print(str)
wz---wyf---jxh
# str="{0}---{name}--{1}".format(("wz","jxh"),name="wyf")
# print(str)
  File "D:/Python_Demo/ASCII.py", line 11, in <module>
    str="{0}---{name}---{1}".format(("wz","jxh"),name="wyf")
IndexError: tuple index out of range
str="{0[0]}---{name}---{0[1]}".format(("wz","jxh"),name="wyf")
print(str)
wz---wyf---jxh
str="{0[0]}---{name}---{0[1]}".format(["wz","jxh"],name="wyf")
print(str)
wz---wyf---jxh

三.元組 

元組:是一個有序,可重複的,不可更改的對象;         
           
特點：
     1.與list類似;
     2.不可變的類型資料;
     3.元組使用的是()

元組的基本使用格式:

(元素1,元組2,...,元組n)
           
基本呢描述：
        元組是用()包裹起來的多個元素的資料類型,每個元素之間用","隔開

1.元組的建立 

1.建立一個空元組
t1 = ()
print(type(t1))
<class 'tuple'>
 st = ()
st1 = tuple()
print(st,st1)
((), ())
print( type(st), type(st1))
(<class 'tuple'>, <class 'tuple'>)

建立隻含有一個元素的元組

需要注意的地方:我們建立的元組隻含有一個元素的元組,我們必須在這僅有的一個元素後加上一個","。

t1=(6)
print(t1,type(t1))
(6, <class 'int'>)


 t1=(6, ) #隻有一個元素的元組，必須加上","
print( t1, type(t1))
((6,), <class 'tuple'>)
  • 建立含有多個元素的元組

和清單一樣,元組的元素也可以試試不同的資料類型的元素

2.元組的基本操作

查

  • 通過索引值查找對應元素 
t1=(1,"hunan",['h','u','n','a','n'],('I','love','you'),{"name":"Tom","age":18})
print(t1[4])
{'name': 'Tom', 'age': 18}
print(t1[-1])
{'name': 'Tom', 'age': 18}
print(t1[::-2])
({'name': 'Tom', 'age': 18}, ['h', 'u', 'n', 'a', 'n'], 1)
  • 查找元素的索引值 
t1=(1,"hunan",['h','u','n','a','n'],('I','love','you'),{"name":"Tom","age":18})
print(t1.index("hunan"))
1

注意:元組是不可變的資料類型:不能夠增,删,改

t1=(1,"hunan",['h','u','n','a','n'],('I','love','you'),{"name":"Tom","age":18})
print(t1[0]=0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

注意到t1裡有個清單,那麼這個清單中的元素是否可以更改

t1=(1,"hunan",['h','u','n','a','n'],('I','love','you'),{"name":"Tom","age":18})
print(t1[2])
['h', 'u', 'n', 'a', 'n']
 t1[2][2]='N'
print(t1)
(1, 'hunan', ['h', 'u', 'N', 'a', 'n'], ('I', 'love', 'you'), {'name': 'Tom', 'age': 18})

2.元組的基本操作

1.拼接

t1=('唐友','蔣新衡','吳振','wyf')  #拼接
t2=('ty','jxh','wz','王餘豐')
print(t1+t2)
('唐友', '蔣新衡', '吳振', 'wyf', 'ty', 'jxh', 'wz', '王餘豐')

2.重複

t1=('唐友','蔣新衡','吳振','wyf')
print(t1*3)
('唐友', '蔣新衡', '吳振', 'wyf', '唐友', '蔣新衡', '吳振', 'wyf', '唐友', '蔣新衡', '吳振', 'wyf')

3.判斷元素是否存在

t1=('唐友','蔣新衡','吳振','wyf')
print('wyf' in  t1)
print('wyf' not in t1)
t1=('唐友','蔣新衡','吳振','wyf')
print('wyf' in  t1)
print('wyf' not in t1)

4.最大小值

t1=('a','b','c')
print(max(t1))
c
print(min(t1))
a
元組周遊

1.值周遊

tp=('python','java','c++')
for i in tp:
  print(i,end=" ")
  python java c++

2.索引周遊

tp=("Python","Java","C++")
for  i in range(len(tp)):
     print(tp[i], end= " ")
     Python Java C++

3.索引-值,周遊

枚舉(enumerate)對于一個疊代的(iterable)/可周遊的對象(如清單,字元串).enumerate将其組成一個索引序列,利用他可以同時獲得索引和值。

tp=('Python','Java','C++')
for index,value in  enumerate(tp):
 print(index,':',value)
0 : Python
1 : Java
2 : C++
tp=('Python','Java','C++')
for index,value in  enumerate(tp,6):
 print(index,':',value)
 6 : Python
7 : Java
8 : C++

四.字典

思考：

場景1

如果有清單

li = ['Pyhton', 'Java', 'C++'];

需要對"pyhton"這個名字寫錯了，通過代碼修改：

li[0] = "Python"

如果清單的順序發生了變化，如下

li = ['Java', 'C++', 'Pyhton'];

此時就需要修改下标，才能完成名字的修改

li[2] = "Python"

有沒有方法，既能存儲多個資料，還能在通路元素的很友善就能夠定位到需要的那個元素呢？

答：

字典

場景2：

學生資訊清單，每個學生資訊包括學号、姓名、年齡等，如何從中找到某個學生的資訊？

studens = [[201801, "張三", 18], [201802, "李四", 19], [201803, "王二"，17], ...]

循環周遊？ 這樣很麻煩。

實際生活中，我們還經常使用漢語字典，英漢詞典等等。

程式中的字典:

info  = {"usrname":"Lilei","age": 18,"Class": "one"}

字典(dictionary)是除清單意外python之中最靈活的内置資料結構類型，字典是一種可變資料類型，且可存儲任意類型對象。清單是有序的對象結合，字典是無序的對象集合。兩者之間的差別在于：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。

格式:

{key1:value1,key2:value2,........}

描述:

1.鍵-值對中間用冒号(":")連接配接；

 2.key:value組成字典裡的一個元素;

 3.鍵-值對(元素)之間用逗号(",")隔開；

 4.整個字典用花括号"{}"包裹起來。

字典的建立

建立一個空字典 

python

dict = {}

type(dict)

建立一個有多個值得字典

1.直接指派法:d={key1:value1,key2:value2},如

info = {"usrname":"Lilei","age": 18,"Class":"two"}
print(info)
{'usrname': 'Lilei', 'age': 18, 'Class': 'two'}

拓展:

key1 = "name"
value1 = "Tom"
key2= "age"
value2 = 18
d={key1 : value1, key2 : value2}
print(d)
{'name': 'Tom', 'age': 18}
           
info = dict((('name', 'LiLei'), ('age', 18)))
info = dict([('name', 'LiLei'), ('age', 18)])
info = dict((['name', 'LiLei'], ['age', 18]))

3.通過字典的fromkeys方法建立字典

info = dict.fromkeys("Hello") # 如果沒有指定預設值，預設為 None；
print( info)
{'H': None, 'e': None, 'l': None, 'o': None}
info = dict.fromkeys(["Lilei","Lee","Jack"], "123456") # 給每個元素設定預設值"123456";
print( info)
{'Lilei': '123456', 'Lee': '123456', 'Jack': '123456'}

字典的常見操作

字典值得通路(查的一種)

字典是無序的，不能通過索引值類擷取值。

info = info[2]
報錯

通過鍵(key)通路值(value)

key值不存在的時候,會報錯

info={"username":"Lilei", "age": 18,"Class": "Two"}
info["username"] # 通過關鍵字通路對應的值
print(info["username"])
Lilei

info["age"]
print(info["age"])
18
info["usname"] # 沒有對應的key，報錯
報錯

使用get通路值(value)

不确定字典中是否存在某個鍵而又想擷取其值時，可以使用get方法，還可以設定預設值

當key不存在的，不會抛出異常，傳回None。

info ={"name" : "Lilei", "age": 18}
info.get("name")
print(info.get("name"))
Lilei
# 當key不存在，不會抛出異常，傳回 None
info.get("job")
print(type(info.get("job")))
<class 'NoneType'>

增

直接添加新鍵-值對

在使用 變量名[‘鍵’] = 資料 時，這個"鍵"在字典中，不存在，那麼就會新增這個元素：

info = {"name":"Lilei", "age": 18}
info["job"]="IT"
print(info)
{'name': 'Lilei', 'age': 18, 'job': 'IT'}
dict.update()

把字典info1的鍵/值對更新到info裡

當兩個字典中的鍵不同時，把info1的鍵值插入到info中

當兩個字典中存在相同鍵時，info1覆寫info的鍵值

# 當兩個字典完全不相同時
info = {"name": "Lilei","age":18}
info1 ={"job": "IT","salary":10000}
info.update(info1)
print(info)
print(info1)
{'name': 'Lilei','age': 18, 'job': 'IT', 'salary': 10000}
{'job': 'It','salary': 10000}
# 當兩個字典存在相同鍵時，會覆寫前面的鍵值
>>> info = {"name": "Lilei", "age" : 18}
>>> info2 = {"name": "Tom", "salary": 10000}
>>> info.update(info2)
>>> info
{'name': 'Tom', 'age': 18, 'salary': 10000}
>>> info2
{'name': 'Tom', 'salary' :10000}
>>>

删

del dict[keys] 

删除指定的元素/鍵-值對

 沒有傳回值
           
info = {'name': 'Tom', 'age': 18, 'salary': 10000}
del info["salary"]
print(info)
info = {'name': 'Tom', 'age': 18, 'salary': 10000}
del info["salary"]
print(info)

del dict

删除整個字典

info = {"name": "Lilei", "age": 18}
del info
 info
報錯

dict.clear()

清空整個字典

info = {"name": "Lilei", "age": 18}
info.clear()
print(info)
{}

dict.pop(keys)

删除指定鍵-值對

info = {'name': 'Tom', 'age': 18, 'salary': 10000}
print(info.pop("age"))
18
print( info)
{'name': 'Tom', 'salary': 10000}
  • dict.popitem()
  • 随機删除字典中的一組鍵值對
  • 有傳回值，以元組的方式傳回
  • 應用不廣泛 
info ={'name': 'Tom', 'age': 18, 'salary': 10000}
print(info.popitem())
('salary', 10000)
print(info)
{'name': 'Tom', 'age': 18}

改

字典的每個元素中的資料是可以修改的，隻要通過key找到，即可修改

直接修改

info = {'name':'Tom','age': 18, 'salary': 10000}
info["name"] = "Lilei"
print(info)
{'name': 'Lilei', 'age': 18, 'salary': 10000}

dict.setdefault()

鍵存在，不改動，傳回字典中字典中相應的值

鍵不存在，在字典中添加相應的鍵值對，并傳回相應的值

# 鍵存在，不改動，傳回字典中相應的值
info = {'name': 'Tom','age': 18,'salary': 10000}
print(info.setdefault("age", 20)) # 有傳回值
18
print(info )
{'name': 'Tom', 'age': 18, 'salary': 10000}
# 鍵不存在，在字典中添加相應的鍵值對，并傳回相應的值
info = {"name": "Lilei", "age" : 18}
info2 = {"name": "Tom", "salary": 10000}
info.update(info2)
print(info)
print(info2)
{'name': 'Tom', 'age': 18, 'salary': 10000}
{'name': 'Tom', 'salary': 10000}

           
dict.keys()
 傳回字典中的所有鍵(keys)
    dict.values()
 傳回字典中的所有值(values)
  dict.items()
傳回字典中的所有鍵-值對(keys-values)
某元素是否存在：
  key in dict
   存在，TRUE
   不存在,false
           
info = {'name': 'Tom','age': 18, 'salary': 10000}
print(info.keys())
dict_keys(['name','age','salary'])

print(info.values())
dict_keys(['Tom',18,10000])

print(info .items())
dict_item([('name','Tom'), ('age',18),('salary',10000)])
 
 print("age" in info)、
 True
 print( "job" in info)
 False

字典的周遊

(1) 周遊字典的鍵(key)

info = {"usename":"Lilei","age": 18,"Class":"one"}
for key in info.keys():
       print(key, end = " ")

(2) 周遊字典的值(value)

info = {"usrname":"Lilei","age": 18,"Class": "one"}
for value in info.values():
      print(value, end = " ")

(3) 周遊所有的項(items)

info = {"usrname":"Lilei","age": 18,"Class": "one"}
for item in info.items():
      print(item, end = " ")

(4)周遊字典的鍵-值對(key-value)

info = {"usrname":"Lilei","age": 18,"Class": "one"}
for key, value in info.items():
      print(key,":", value,end = " ")             print(key,":", value,end = " ")

五.集合 

集合是無序的,不重複的且不可以更改的資料集合它裡面的元素是可哈希的(不可變的類型),但集合本身就是不可哈希(是以集合是做不了字典的鍵的),以下是集合最重要的兩點：
    1.去重:把一個清單變成了集合,就在自動去重了
    2.關系:測試兩組資料之前的交集,差集,并集等關系

集合的建立

建立一個空的集合

這裡注意我們不可以直接用花括号"{}"

st=set()
print(st)
set()
st1={}
print(type(st),type(st1))
<class 'set'> <class 'dict'>

多元素的集合建立 

st={"a","b","c","d","e"}
print(st,type(st))
{'b', 'd', 'e', 'c', 'a'} <class 'set'>
st={1,2,3,[1,2]}
print(st)
Traceback (most recent call last):
  File "D:/Python_Demo/ks.py", line 78, in <module>
    st={1,2,3,[1,2]}
TypeError: unhashable type: 'list'
st={1,2,3,{"age:"18}}
print(str)
  File "D:/Python_Demo/ks.py", line 82
    st={1,2,3,{"age:"18}}
                      ^
SyntaxError: invalid syntax
   #不可以放清單和元組

集合的強轉 

li=[1,"a","n","University"]
st_li=set(li)
print(st_li,type(st_li))
{1, 'n', 'University', 'a'} <class 'set'>
str="Universitysity"
st_str=set(str)
print(st_str,type(st_str))
{'r', 't', 'i', 'v', 'y', 'U', 'n', 's', 'e'} <class 'set'>
dic={"a":1,"b":2,"c":3,"d":4}
st_dic=set(dic)
print(st_dic,type(st_dic))
{'c', 'b', 'd', 'a'} <class 'set'>
  • list()
  • str()
  • tupel()
  • dict()
  • set()

    集合的基本操作

    查

    無序,

    不可查找

    增 

    set.add()
st={1,2,"Hunan","YingXiao","Collage"}
st.add("Computer Science")
print(st)
{1, 'Hunan', 2, 'Collage', 'Computer Science', 'YingXiao'}
set.update()
st.update("湖南","長沙")
print(st)
{'YingXiao', 1, 2, '湖', '沙', '南', '長', 'Collage', 'Hunan', 'Computer Science'}

    删 

    set.pop()
st={1,2,"Hunan","YingXiao","Collage"}
print(st.pop())#删除排序最小一的元素
print(st)
1
{2, 'Collage', 'Hunan', 'YingXiao'}
set.discard()
st={1,2,"Hunan","YingXiao","Collage"}
st.discard(2)#移除元素
print(st)
{1, 'YingXiao', 'Collage', 'Hunan'}
st.discard("HUNAN")#如果元素不存在,不會報錯,不做任何操作
print(st)
{1, 'YingXiao', 'Collage', 'Hunan'}
set.remove()
st={1,2,"Hunan","YingXiao","Collage"}
st.remove(2)
print(st)
   {1, 'Hunan', 'Collage', 'YingXiao'}
st.remove("HUNAN")
print(st)
Traceback (most recent call last):
  File "D:/Python_Demo/ks.py", line 40, in <module>
    st.remove("HUNAN")
KeyError: 'HUNAN'
           
    set.clear()
st={1,2,3}
st.clear()
print(st)
set()
del set()
st={1,2,3}
del set
print(st)
  File "D:/Python_Demo/ks.py", line 46, in <module>
    del set
NameError: name 'set' is not defined

    改,不可以更改 

    st[0]="HUNAN"
print(st[0])
Traceback (most recent call last):
  File "D:/Python_Demo/ks.py", line 48, in <module>
    st[0]="HUNAN"
NameError: name 'st' is not defined
    周遊 
    st = {1, 2, "Hunan", "YingXiao", "Collage"}
for i in st:
    print(i,end= " ")
    1 2 Hunan YingXiao Collage 
    st = {1, 2, "Hunan", "YingXiao", "Collage"}
    for index ,value in enumerate(st):
        print(index, value)        
0 1
1 2
2 Hunan
3 Collage
4 YingXiao

比較

集合的基本運算

1.子集
a=set("abcd")
b=set("cdef")
c=set("ab")
print(a,b,c)
{'c', 'd', 'a', 'b'} {'e', 'd', 'f', 'c'} {'a', 'b'}
print(c.issubset(a))
True
print(c<a)
True
print(c<b)
Fals
2.交集
a=set("abcd")
b=set("cdef")
print(a.intersection(b))
print(a&b)
{'c', 'd'}
{'c', 'd'}
3.并集
a=set("abcd")
b=set("cdef")
print(a.union(b))
{'d', 'e', 'b', 'c', 'a', 'f'}
print(a|b)
{'d', 'e', 'b', 'c', 'a', 'f'}
4.差集
a=set("abcd")
b=set("cdef")
print(a.difference(b))
{'b', 'a'}
print(a-b)
{'b', 'a'}
python筆記
上一篇: 字元串 清單 字典 元組 集合
下一篇: Python内置序列之清單、元組、字元串、集合以及字典

繼續閱讀