字符串

認識字符串

字符串是 Python 中最常用的數(shù)據(jù)類型疾就。我們一般使用引號來創(chuàng)建字符串俐东。創(chuàng)建字符串很簡單古涧，只要為變量分配一個值即可蜜暑。

a = 'hello world'
b = "abcdefg"
print(type(a))
print(type(b))

注意：控制臺顯示結(jié)果為<class 'str'>添寺， 即數(shù)據(jù)類型為str(字符串)斧抱。

一對引號字符串

name1 = 'Tom'
name2 = "Rose"

三引號字符串

name3 = ''' Tom '''
name4 = """ Rose """
a = ''' i am Tom, 
        nice to meet you! '''

b = """ i am Rose, 
        nice to meet you! """

注意：三引號形式的字符串支持換行娇豫。

思考：如果創(chuàng)建一個字符串I'm Tom?

c = "I'm Tom"
d = 'I\'m Tom'

小總結(jié)：

雙引號或者單引號中的數(shù)據(jù)耀找，就是字符串

字符串輸出

1.格式化操作符

    name = 'xx'
    position = 'yy'
    address = 'zz'

    print('--------------------------------------------------')
    print("姓名：%s" % name)
    print("職位：%s" % position)
    print("公司地址：%s" % address)
    print('--------------------------------------------------')

2.f-strings
f-strings 提供一種簡潔易讀的方式, 可以在字符串中包含 Python 表達式. f-strings 以字母 'f' 或 'F' 為前綴, 格式化字符串使用一對單引號此洲、雙引號厂汗、三單引號、三雙引號. 格式化字符串中

name = 'xx'
age = 18
format_string1 = f'我的名字是 {name}, 我的年齡是 {age}'
format_string2 = f"我的名字是 {name}, 我的年齡是 {age}"
format_string3 = F'''我的名字是 {name}, 我的年齡是 {age}'''
format_string4 = F"""我的名字是 {name}, 我的年齡是 {age}"""
format_string5 = f'3 + 5 = {3 + 5}'
a = 10
b = 20
format_string6 = f'3 + 5 = {a + b}'
# 注意{{}} 不表示表達式
format_string7 = F'我的名字是 {{name}}, 我的年齡是 {{age}}'

print(format_string1)
print(format_string2)
print(format_string3)
print(format_string4)
print(format_string5)
print(format_string6)
print(format_string7)

字符串輸入

之前在學(xué)習(xí)input的時候呜师，通過它能夠完成從鍵盤獲取數(shù)據(jù)娶桦，然后保存到指定的變量中；

注意：input獲取的數(shù)據(jù)，都以字符串的方式進行保存衷畦，即使輸入的是數(shù)字氮双，那么也是以字符串方式保存

demo:

    userName = input('請輸入用戶名:')
    print("用戶名為：%s" % userName)

    password = input('請輸入密碼:')
    print("密碼為：%s" % password)

下標(biāo)索引

所謂“下標(biāo)”，就是編號霎匈，就好比超市中的存儲柜的編號戴差，通過這個編號就能找到相應(yīng)的存儲空間

• 生活中的 "下標(biāo)"

  超市儲物柜

  
  
  image.png

• 字符串中"下標(biāo)"的使用

  列表與元組支持下標(biāo)索引好理解，字符串實際上就是字符的數(shù)組铛嘱，所以也支持下標(biāo)索引暖释。

  如果有字符串:name = 'abcdef'，在內(nèi)存中的實際存儲如下:

image.png

如果想取出部分字符墨吓，那么可以通過下標(biāo)的方法球匕，（注意python中下標(biāo)從 0 開始）

```
   name = 'abcdef'
   print(name[0])
   print(name[1])
   print(name[2])

```

運行結(jié)果:

a
b
c

切片

切片是指對操作的對象截取其中一部分的操作。字符串帖烘、列表亮曹、元組都支持切片操作。

切片的語法：[起始:結(jié)束:步長]

注意：選取的區(qū)間從"起始"位開始秘症，到"結(jié)束"位的前一位結(jié)束（不包含結(jié)束位本身)照卦，步長表示選取間隔。

我們以字符串為例講解乡摹。

如果取出一部分役耕，則可以在中括號[]中，使用:

     name = 'abcdef'

     print(name[0:3]) # 取 下標(biāo)0~2 的字符

運行結(jié)果:

abc

     name = 'abcdef'

     print(name[3:5]) # 取 下標(biāo)為3聪廉、4 的字符

運行結(jié)果:
de

     name = 'abcdef'

     print(name[2:]) # 取 下標(biāo)為2開始到最后的字符

運行結(jié)果:
cdef

     name = 'abcdef'

     print(name[1:-1]) # 取 下標(biāo)為1開始 到 最后第2個  之間的字符

運行結(jié)果:
bcde

其他例子

 >>> a = "abcdef"
 >>> a[:3]
 'abc'
 >>> a[::2]
 'ace'
 >>> a[5:1:2] 
 ''
 >>> a[1:5:2]
 'bd'
 >>> a[::-2]
 'fdb' 
 >>> a[5:1:-2]
 'fd'

想一想

• （面試題）給定一個字符串a(chǎn)Str, 請反轉(zhuǎn)字符串

# 索引是通過下標(biāo)取某一個元素
# 切片是通過下標(biāo)去某一段元素

s = 'Hello World!'

print(s[4])

print(s)

print(s[:]) # 取出所有元素（沒有起始位和結(jié)束位之分）瞬痘，默認步長為1

print(s[1:]) # 從下標(biāo)為1開始，取出 后面所有的元素（沒有結(jié)束位）

print(s[:5])  # 從起始位置開始板熊，取到 下標(biāo)為5的前一個元素（不包括結(jié)束位本身）

print(s[:-1]) # 從起始位置開始框全，取到 倒數(shù)第一個元素（不包括結(jié)束位本身）

print(s[-4:-1]) # 從倒數(shù)第4個元素開始，取到 倒數(shù)第1個元素（不包括結(jié)束位本身）

print(s[1:5:2]) # 從下標(biāo)為1開始干签，取到下標(biāo)為5的前一個元素津辩，步長為2（不包括結(jié)束位本身）

# python 字符串快速逆置
print(s[::-1])  # 從后向前，按步長為1進行取值

字符串常見操作

如有字符串mystr = 'hello world itcast and itcastcpp'筒严，以下是常見的操作

<1>find

檢測 str 是否包含在 mystr中丹泉，如果是返回開始的索引值，否則返回-1

1. 語法

   字符串序列.find(子串, 開始位置下標(biāo), 結(jié)束位置下標(biāo))
   
   

2. 示例

   mystr.find(str, start=0, end=len(mystr))
   
   

<2>index

跟find()方法一樣鸭蛙，只不過如果str不在 mystr中會報一個異常.

1. 語法

   字符串序列.index(子串, 開始位置下標(biāo), 結(jié)束位置下標(biāo))
   
   

2. 示例

   mystr.index(str, start=0, end=len(mystr))
   
   

<3>count

返回 str在start和end之間 在 mystr里面出現(xiàn)的次數(shù)

1. 語法

   字符串序列.count(子串, 開始位置下標(biāo), 結(jié)束位置下標(biāo))
   
   

2. 示例

   mystr.count(str, start=0, end=len(mystr))
   
   

<4>replace

把 mystr 中的 str1 替換成 str2,如果 count 指定，則替換不超過 count 次.

1. 語法

   字符串序列.replace(舊子串, 新子串, 替換次數(shù))
   
   

2. 示例

   mystr.replace(str1, str2,  mystr.count(str1))
   
   

<5>split

以 str 為分隔符切片 mystr筋岛，如果 maxsplit有指定值娶视，則僅分隔 maxsplit 個子字符串

1. 語法

   字符串序列.split(分割字符, num)
   
   

2. 示例

   mystr.split(str=" ", 2)
   
   

<6>capitalize

把字符串的第一個字符大寫

mystr.capitalize()

<7>title

把字符串的每個單詞首字母大寫

>>> a = "hello itcast"
>>> a.title()
'Hello Itcast'

<8>startswith

檢查字符串是否是以 hello 開頭, 是則返回 True，否則返回 False

1. 語法

字符串序列.startswith(子串, 開始位置下標(biāo), 結(jié)束位置下標(biāo))

2.示例

mystr.startswith(hello)

<9>endswith

檢查字符串是否以obj結(jié)束，如果是返回True,否則返回 False.

mystr.endswith(obj)

<10>lower

轉(zhuǎn)換 mystr 中所有大寫字符為小寫

mystr.lower()        

<11>upper

轉(zhuǎn)換 mystr 中的小寫字母為大寫

mystr.upper()    

<12>ljust

返回一個原字符串左對齊,并使用空格填充至長度 width 的新字符串

mystr.ljust(width) 

<13>rjust

返回一個原字符串右對齊,并使用空格填充至長度 width 的新字符串

mystr.rjust(width)    

<14>center

返回一個原字符串居中,并使用空格填充至長度 width 的新字符串

mystr.center(width)   

<15>lstrip

刪除 mystr 左邊的空白字符

mystr.lstrip()

<16>rstrip

刪除 mystr 字符串末尾的空白字符

mystr.rstrip()    

<17>strip

刪除mystr字符串兩端的空白字符

>>> a = "\n\t itcast \t\n"
>>> a.strip()
'itcast'

<18>rfind

類似于 find()函數(shù)肪获，不過是從右邊開始查找.

mystr.rfind(str, start=0,end=len(mystr) )

<19>rindex

類似于 index()寝凌，不過是從右邊開始.

mystr.rindex( str, start=0,end=len(mystr))

<20>partition

把mystr以str分割成三部分,str前，str和str后

mystr.partition(str)

<21>rpartition

類似于 partition()函數(shù),不過是從右邊開始.

mystr.rpartition(str)

<22>splitlines

按照行分隔孝赫，返回一個包含各行作為元素的列表

mystr.splitlines()  

<23>isalpha

如果 mystr 所有字符都是字母 則返回 True,否則返回 False

mystr.isalpha()  

<24>isdigit

如果 mystr 只包含數(shù)字則返回 True 否則返回 False.

mystr.isdigit() 

<25>isalnum

如果 mystr 所有字符都是字母或數(shù)字則返回 True,否則返回 False

mystr.isalnum()  

<26>isspace

如果 mystr 中只包含空格较木，則返回 True，否則返回 False.

mystr.isspace()   

<27>join

mystr 中每個元素后面插入str,構(gòu)造出一個新的字符串

1. 語法

   字符或子串.join(多字符串組成的序列)
   
   

2. 示例

   mystr.join(str)
   
   

想一想

• （面試題）給定一個字符串a(chǎn)Str青柄，返回使用空格或者'\t'分割后的倒數(shù)第二個子串

列表

想一想：

前面學(xué)習(xí)的字符串可以用來存儲一串信息伐债，那么想一想，怎樣存儲咱們班所有同學(xué)的名字呢致开？

定義100個變量峰锁，每個變量存放一個學(xué)生的姓名可行嗎？有更好的辦法嗎双戳？

答：列表

<1>列表的格式
變量A的類型為列表

namesList = ['xiaoWang','xiaoZhang','xiaoHua']

比C語言的數(shù)組強大的地方在于列表中的元素可以是不同類型的

testList = [1, 'a']

<2>打印列表
demo:

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[0])
print(namesList[1])
print(namesList[2])

結(jié)果：

xiaoWang
xiaoZhang
xiaoHua

列表的相關(guān)操作

列表中存放的數(shù)據(jù)是可以進行修改的虹蒋，比如"增"、"刪"飒货、"改"魄衅、"查"

<1>添加元素("增"append, extend, insert)

append

通過append可以向列表添加元素

demo:

    #定義變量A，默認有3個元素
    A = ['xiaoWang','xiaoZhang','xiaoHua']

    print("-----添加之前塘辅，列表A的數(shù)據(jù)-----")
    for tempName in A:
        print(tempName)

    #提示徐绑、并添加元素
    temp = input('請輸入要添加的學(xué)生姓名:')
    A.append(temp)

    print("-----添加之后，列表A的數(shù)據(jù)-----")
    for tempName in A:
        print(tempName)

列表追加數(shù)據(jù)的時候莫辨，直接在原列表里面追加了指定數(shù)據(jù)傲茄，即修改了原列表，故列表為可變類型數(shù)據(jù)沮榜。

注意點

如果append()追加的數(shù)據(jù)是一個序列盘榨，則追加整個序列到列表

name_list = ['Tom', 'Lily', 'Rose']

name_list.append(['xiaoming', 'xiaohong'])

# 結(jié)果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
print(name_list)

extend

通過extend可以將另一個集合中的元素逐一添加到列表中

>>> a = [1, 2]
>>> b = [3, 4]
>>> a.append(b)
>>> a
[1, 2, [3, 4]]
>>> a.extend(b)
>>> a
[1, 2, [3, 4], 3, 4]

insert

insert(index, object) 在指定位置index前插入元素object

>>> a = [0, 1, 2]
>>> a.insert(1, 3)
>>> a
[0, 3, 1, 2]

<2>修改元素("改")

修改元素的時候，要通過下標(biāo)來確定要修改的是哪個元素蟆融，然后才能進行修改

demo:

    #定義變量A草巡，默認有3個元素
    A = ['xiaoWang','xiaoZhang','xiaoHua']

    print("-----修改之前，列表A的數(shù)據(jù)-----")
    for tempName in A:
        print(tempName)

    #修改元素
    A[1] = 'xiaoLu'

    print("-----修改之后型酥，列表A的數(shù)據(jù)-----")
    for tempName in A:
        print(tempName)

結(jié)果:

    -----修改之前山憨，列表A的數(shù)據(jù)-----
    xiaoWang
    xiaoZhang
    xiaoHua
    -----修改之后，列表A的數(shù)據(jù)-----
    xiaoWang
    xiaoLu
    xiaoHua

<3>查找元素("查"in, not in, index, count)

所謂的查找弥喉，就是看看指定的元素是否存在

in, not in

python中查找的常用方法為：

• in（存在）,如果存在那么結(jié)果為true郁竟，否則為false
• not in（不存在），如果不存在那么結(jié)果為true由境，否則false

demo

    #待查找的列表
    nameList = ['xiaoWang','xiaoZhang','xiaoHua']

    #獲取用戶要查找的名字
    findName = input('請輸入要查找的姓名:')

    #查找是否存在
    if findName in nameList:
        print('在字典中找到了相同的名字')
    else:
        print('沒有找到')

說明：

in的方法只要會用了棚亩，那么not in也是同樣的用法蓖议，只不過not in判斷的是不存在

index, count

index()：返回指定數(shù)據(jù)所在位置的下標(biāo)

count()：統(tǒng)計指定數(shù)據(jù)在當(dāng)前列表中出現(xiàn)的次數(shù)

>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左閉右開區(qū)間
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

下標(biāo)

name_list = ['Tom', 'Lily', 'Rose']

print(name_list[0])  # Tom
print(name_list[1])  # Lily
print(name_list[2])  # Rose

len()：訪問列表長度，即列表中數(shù)據(jù)的個數(shù)讥蟆。

name_list = ['Tom', 'Lily', 'Rose']

print(len(name_list))  # 3

<4>刪除元素("刪"del, pop, remove)

類比現(xiàn)實生活中勒虾，如果某位同學(xué)調(diào)班了，那么就應(yīng)該把這個條走后的學(xué)生的姓名刪除掉瘸彤；在開發(fā)中經(jīng)常會用到刪除這種功能修然。

列表元素的常用刪除方法有：

• del：根據(jù)下標(biāo)進行刪除
• pop：刪除最后一個元素
• remove：根據(jù)元素的值進行刪除

demo:(del)

1. 語法

del 目標(biāo)

    movieName = ['加勒比海盜','駭客帝國','第一滴血','指環(huán)王','霍比特人','速度與激情']

    print('------刪除之前------')
    for tempName in movieName:
        print(tempName)

    del movieName[2] #刪除指定數(shù)據(jù)
    # del movieName  #刪除列表
    print('------刪除之后------')
    for tempName in movieName:
        print(tempName)

結(jié)果:

    ------刪除之前------
    加勒比海盜
    駭客帝國
    第一滴血
    指環(huán)王
    霍比特人
    速度與激情
    ------刪除之后------
    加勒比海盜
    駭客帝國
    指環(huán)王
    霍比特人
    速度與激情

demo:(pop)

1. 語法:

列表序列.pop(下標(biāo))

    movieName = ['加勒比海盜','駭客帝國','第一滴血','指環(huán)王','霍比特人','速度與激情']

    print('------刪除之前------')
    for tempName in movieName:
        print(tempName)

    movieName.pop()

    print('------刪除之后------')
    for tempName in movieName:
        print(tempName)

結(jié)果:

    ------刪除之前------
    加勒比海盜
    駭客帝國
    第一滴血
    指環(huán)王
    霍比特人
    速度與激情
    ------刪除之后------
    加勒比海盜
    駭客帝國
    第一滴血
    指環(huán)王
    霍比特人

demo:(remove)

1. 語法

列表序列.remove(數(shù)據(jù))

    movieName = ['加勒比海盜','駭客帝國','第一滴血','指環(huán)王','霍比特人','速度與激情']

    print('------刪除之前------')
    for tempName in movieName:
        print(tempName)

    movieName.remove('指環(huán)王')

    print('------刪除之后------')
    for tempName in movieName:
        print(tempName)

結(jié)果:

    ------刪除之前------
    加勒比海盜
    駭客帝國
    第一滴血
    指環(huán)王
    霍比特人
    速度與激情
    ------刪除之后------
    加勒比海盜
    駭客帝國
    第一滴血
    霍比特人
    速度與激情

demo:(clear)[清空列表]

movieName = ['加勒比海盜','駭客帝國','第一滴血','指環(huán)王','霍比特人','速度與激情']
movieName.clear()
print(movieName)

<5>排序(sort, reverse)

sort方法是將list按特定順序重新排列，默認為由小到大质况，參數(shù)reverse=True可改為倒序愕宋，由大到小。

reverse方法是將list逆置拯杠。

>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 4, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]

<6>復(fù)制(copy)

函數(shù)：copy()

movieName = ['加勒比海盜','駭客帝國','第一滴血','指環(huán)王','霍比特人','速度與激情']
movieName2 = movieName.copy()
print(movieName2)

列表的循環(huán)遍歷

1. 使用for循環(huán)
   為了更有效率的輸出列表的每個數(shù)據(jù)掏婶，可以使用循環(huán)來完成

demo:

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:
    print(name)

結(jié)果:

xiaoWang
xiaoZhang
xiaoHua

2. 使用while循環(huán)
   為了更有效率的輸出列表的每個數(shù)據(jù)，可以使用循環(huán)來完成

demo:

namesList = ['xiaoWang','xiaoZhang','xiaoHua']

length = len(namesList)

i = 0

while i<length:
    print(namesList[i])
    i+=1

結(jié)果:

xiaoWang
xiaoZhang
xiaoHua

列表的嵌套

1. 列表嵌套

類似while循環(huán)的嵌套潭陪，列表也是支持嵌套的

一個列表中的元素又是一個列表雄妥，那么這就是列表的嵌套

    schoolNames = [['北京大學(xué)','清華大學(xué)'],
                    ['南開大學(xué)','天津大學(xué)','天津師范大學(xué)'],
                    ['山東大學(xué)','中國海洋大學(xué)']]

2. 應(yīng)用

一個學(xué)校，有3個辦公室依溯，現(xiàn)在有8位老師等待工位的分配老厌，請編寫程序，完成隨機的分配

#encoding=utf-8

import random

# 定義一個列表用來保存3個辦公室
offices = [[],[],[]]

# 定義一個列表用來存儲8位老師的名字
names = ['A','B','C','D','E','F','G','H']

i = 0
for name in names:
    index = random.randint(0,2)    
    offices[index].append(name)

i = 1
for tempNames in offices:
    print('辦公室%d的人數(shù)為:%d'%(i,len(tempNames)))
    i+=1
    for name in tempNames:
        print("%s"%name,end='')
    print("\n")
    print("-"*20)

元組

Python的元組與列表類似黎炉，不同之處在于元組的元素不能修改枝秤。元組使用小括號，列表使用方括號慷嗜。

定義元組:

元組特點：定義元組使用小括號淀弹，且逗號隔開各個數(shù)據(jù)，數(shù)據(jù)可以是不同的數(shù)據(jù)類型庆械。

>>> aTuple = ('et',77,99.9)
>>> aTuple
('et',77,99.9)
>>> aTuple = (10,)

注意：如果定義的元組只有一個數(shù)據(jù)薇溃，那么這個數(shù)據(jù)后面也好添加逗號，否則數(shù)據(jù)類型為唯一的這個數(shù)據(jù)的數(shù)據(jù)類型

<1>訪問元組(下標(biāo)訪問)

image.png

<2>修改元組

image.png

說明： python中不允許修改元組的數(shù)據(jù)缭乘，包括不能刪除其中的元素沐序。

<3>count, index, len

index()：查找某個數(shù)據(jù)，如果數(shù)據(jù)存在返回對應(yīng)的下標(biāo)堕绩，否則報錯策幼，語法和列表、字符串的index方法相同奴紧。

count()：統(tǒng)計某個數(shù)據(jù)在當(dāng)前元組出現(xiàn)的次數(shù)特姐。

len()：統(tǒng)計元組中數(shù)據(jù)的個數(shù)。

>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左閉右開區(qū)間
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0
>>> print(len(a))

注意

但是如果元組里面有列表绰寞，修改列表里面的數(shù)據(jù)則是支持的到逊，故自覺很重要

tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2])  # 訪問到列表

### 結(jié)果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple2[2][0] = 'aaaaa'
print(tuple2)

字典

想一想：

如果有列表

nameList = ['xiaoZhang', 'xiaoWang', 'xiaoLi'];

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

nameList[1] = 'xiaoxiaoWang'

如果列表的順序發(fā)生了變化滤钱，如下

nameList = ['xiaoWang', 'xiaoZhang',  'xiaoLi'];

此時就需要修改下標(biāo)觉壶，才能完成名字的修改

nameList[0] = 'xiaoxiaoWang'

有沒有方法，既能存儲多個數(shù)據(jù)件缸，還能在訪問元素的很方便就能夠定位到需要的那個元素呢铜靶？

答：

字典

另一個場景：

學(xué)生信息列表，每個學(xué)生信息包括學(xué)號他炊、姓名争剿、年齡等，如何從中找到某個學(xué)生的信息痊末？

>>> studens = [[1001, "王bao強", 24], [1002, "馬rong", 23], [1005, "宋x"蚕苇，24], ...]

循環(huán)遍歷？ No凿叠！

python中的字典

變量info為字典類型：

info = {'name':'班長', 'id':100, 'sex':'f', 'address':'地球亞洲中國北京'}

說明：

• 字典和列表一樣涩笤，也能夠存儲多個數(shù)據(jù)
• 列表中找某個元素時，是根據(jù)下標(biāo)進行的
• 字典中找某個元素時盒件，是根據(jù)'名字'（就是冒號:前面的那個值蹬碧，例如上面代碼中的'name'、'id'炒刁、'sex'）
• 字典的每個元素由2部分組成恩沽，鍵:值。例如 'name':'班長' ,'name'為鍵翔始，'班長'為值

創(chuàng)建字典

字典特點：

• 符號為大括號
• 數(shù)據(jù)為鍵值對形式出現(xiàn)
• 各個鍵值對之間用逗號隔開

# 有數(shù)據(jù)字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

# 空字典
dict2 = {}

dict3 = dict()

注意：一般稱冒號前面的為鍵(key)罗心，簡稱k；冒號后面的為值(value)城瞎，簡稱v渤闷。

根據(jù)鍵訪問值

info = {'name':'班長', 'id':100, 'sex':'f', 'address':'地球亞洲中國北京'}

print(info['name'])
print(info['address'])

結(jié)果:

班長
地球亞洲中國北京

若訪問不存在的鍵，則會報錯：

>>> info['age']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'age'

在我們不確定字典中是否存在某個鍵而又想獲取其值時全谤，可以使用get方法肤晓，還可以設(shè)置默認值：

>>> age = info.get('age')
>>> age #'age'鍵不存在，所以age為None
>>> type(age)
<type 'NoneType'>
>>> age = info.get('age', 18) # 若info中不存在'age'這個鍵认然，就返回默認值18
>>> age
18

字典的常見操作

<1>查看元素

除了使用key查找數(shù)據(jù)补憾，還可以使用get來獲取數(shù)據(jù)

demo:

    info = {'name':'吳彥祖','age':18}

    print(info['age']) # 獲取年齡

    # print(info['sex']) # 獲取不存在的key，會發(fā)生異常

    print(info.get('sex')) # 獲取不存在的key卷员，獲取到空的內(nèi)容盈匾，不會出現(xiàn)異常

<2>修改元素

字典的每個元素中的數(shù)據(jù)是可以修改的，只要通過key找到毕骡，即可修改

demo:

    info = {'name':'班長', 'id':100, 'sex':'f', 'address':'地球亞洲中國北京'}

    newId = input('請輸入新的學(xué)號')

    info['id'] = int(newId)

    print('修改之后的id為%d:'%info['id'])

<3>添加元素

demo:訪問不存在的元素

    info = {'name':'班長', 'sex':'f', 'address':'地球亞洲中國北京'}

    print('id為:%d'%info['id'])

如果在使用 **變量名['鍵'] = 數(shù)據(jù) **時削饵，這個“鍵”在字典中岩瘦，不存在，那么就會新增這個元素

demo:添加新的元素

    info = {'name':'班長', 'sex':'f', 'address':'地球亞洲中國北京'}

    # print('id為:%d'%info['id'])#程序會終端運行窿撬，因為訪問了不存在的鍵

    newId = input('請輸入新的學(xué)號')

    info['id'] = newId

    print('添加之后的id為:%d'%info['id'])

結(jié)果:

    請輸入新的學(xué)號188
    添加之后的id為: 188

<4>刪除元素

對字典進行刪除操作启昧，有一下幾種：

• del
• clear()

demo:del刪除指定的元素

    info = {'name':'班長', 'sex':'f', 'address':'地球亞洲中國北京'}

    print('刪除前,%s'%info['name'])

    del info['name']

    print('刪除后,%s'%info['name'])

demo:del刪除整個字典

    info = {'name':'monitor', 'sex':'f', 'address':'China'}

    print('刪除前,%s'%info)

    del info

    print('刪除后,%s'%info)

demo:clear清空整個字典

    info = {'name':'monitor', 'sex':'f', 'address':'China'}

    print('清空前,%s'%info)

    info.clear()

    print('清空后,%s'%info)

結(jié)果

字典的常見操作2

<1>len()

測量字典中，鍵值對的個數(shù)

<2>keys

返回一個包含字典所有KEY的列表

<3>values

返回一個包含字典所有value的列表

<4>items

返回一個包含所有（鍵劈伴，值）元祖的列表

<5>has_key （Python3 已取消）

dict.has_key(key)如果key在字典中密末，返回True，否則返回False

遍歷

通過for ... in ... 我們可以遍歷字符串跛璧、列表严里、元組、字典等

注意python語法的縮進

1. 字符串遍歷

>>> a_str = "hello itcast"
>>> for char in a_str:
...     print(char,end=' ')
...
h e l l o   i t c a s t

2. 列表遍歷

>>> a_list = [1, 2, 3, 4, 5]
>>> for num in a_list:
...     print(num,end=' ')
...
1 2 3 4 5

3. 元組遍歷

>>> a_turple = (1, 2, 3, 4, 5)
>>> for num in a_turple:
...     print(num,end=" ")
1 2 3 4 5

4. 字典遍歷

image.png

4. 想一想追城，如何實現(xiàn)帶下標(biāo)索引的遍歷

>>> chars = ['a', 'b', 'c', 'd']
>>> i = 0
>>> for chr in chars:
...     print("%d %s"%(i, chr))
...     i += 1
...
0 a
1 b
2 c
3 d

有序字典:OrderDcit

我們先看一段代碼, 此代碼運行在 Python3.5 版本中:

# 創(chuàng)建無序字典
my_dict = dict()
# 向字典中添加元素
my_dict['one'] = 1
my_dict['two'] = 2
my_dict['three'] = 3
my_dict['four'] = 4
print(my_dict)

輸出結(jié)果(不固定):

{'three': 3, 'two': 2, 'four': 4, 'one': 1}

輸出結(jié)果并不是按照我們創(chuàng)建字典刹碾、添加元素的順序輸出, 這是由于 dict 是無序的. 如果我們想最終打印輸出的順序和我們操作時的順序保持一致, 我們就需要使用有序字典:

from collections import OrderedDict

# 創(chuàng)建有序字典
my_dict = OrderedDict()
# 向字典中添加元素
my_dict['one'] = 1
my_dict['two'] = 2
my_dict['three'] = 3
my_dict['four'] = 4
print(my_dict)

輸出結(jié)果:

OrderedDict([('one', 1), ('two', 2), ('three', 3), ('four', 4)])

在 Python3.6 版本中, dict 字典已經(jīng)經(jīng)過優(yōu)化, 變?yōu)橛行蜃值? 并且字典所占用的內(nèi)存占用減少了20％到25％.

第一段代碼在 Python3.6 運行下, 輸出結(jié)果如下:

{'one': 1, 'two': 2, 'three': 3, 'four': 4}

集合

創(chuàng)建集合

創(chuàng)建集合使用{}或set()， 但是如果要創(chuàng)建空集合只能使用set()座柱，因為{}用來創(chuàng)建空字典迷帜。

s1 = {10, 20, 30, 40, 50}
print(s1)

s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2)

s3 = set('abcdefg')
print(s3)

s4 = set()
print(type(s4))  # set

s5 = {}
print(type(s5))  # dict

特點：

1. 集合可以去掉重復(fù)數(shù)據(jù)；
2. 集合數(shù)據(jù)是無序的辆布，故不支持下標(biāo)

集合常見操作方法

增加數(shù)據(jù)

• add()

s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1)  # {100, 10, 20}

因為集合有去重功能瞬矩，所以，當(dāng)向集合內(nèi)追加的數(shù)據(jù)是當(dāng)前集合已有數(shù)據(jù)的話锋玲，則不進行任何操作景用。

• update(), 追加的數(shù)據(jù)是序列。

s1 = {10, 20}
# s1.update(100)  # 報錯
s1.update([100, 200])
s1.update('abc')
print(s1)

刪除數(shù)據(jù)

• remove()惭蹂，刪除集合中的指定數(shù)據(jù)伞插，如果數(shù)據(jù)不存在則報錯。

s1 = {10, 20}

s1.remove(10)
print(s1)

s1.remove(10)  # 報錯
print(s1)

• discard()盾碗，刪除集合中的指定數(shù)據(jù)媚污，如果數(shù)據(jù)不存在也不會報錯。

s1 = {10, 20}

s1.discard(10)
print(s1)

s1.discard(10)
print(s1)

• pop()廷雅，隨機刪除集合中的某個數(shù)據(jù)耗美，并返回這個數(shù)據(jù)。

s1 = {10, 20, 30, 40, 50}

del_num = s1.pop()
print(del_num)
print(s1)

查找數(shù)據(jù)

• in：判斷數(shù)據(jù)在集合序列
• not in：判斷數(shù)據(jù)不在集合序列

s1 = {10, 20, 30, 40, 50}

print(10 in s1)
print(10 not in s1)

公共方法

運算符

+

# 1\. 字符串 
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3)  # aabb

# 2\. 列表 
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3)  # [1, 2, 10, 20]

# 3\. 元組 
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(t3)  # (10, 20, 100, 200)

*

# 1\. 字符串
print('-' * 10)  # ----------

# 2\. 列表
list1 = ['hello']
print(list1 * 4)  # ['hello', 'hello', 'hello', 'hello']

# 3\. 元組
t1 = ('world',)
print(t1 * 4)  # ('world', 'world', 'world', 'world')

in或not in

# 1\. 字符串
print('a' in 'abcd')  # True
print('a' not in 'abcd')  # False

# 2\. 列表
list1 = ['a', 'b', 'c', 'd']
print('a' in list1)  # True
print('a' not in list1)  # False

# 3\. 元組
t1 = ('a', 'b', 'c', 'd')
print('aa' in t1)  # False
print('aa' not in t1)  # True

方法

len()

# 1\. 字符串
str1 = 'abcdefg'
print(len(str1))  # 7

# 2\. 列表
list1 = [10, 20, 30, 40]
print(len(list1))  # 4

# 3\. 元組
t1 = (10, 20, 30, 40, 50)
print(len(t1))  # 5

# 4\. 集合
s1 = {10, 20, 30}
print(len(s1))  # 3

# 5\. 字典
dict1 = {'name': 'Rose', 'age': 18}
print(len(dict1))  # 2

del()

# 1\. 字符串
str1 = 'abcdefg'
del str1
print(str1)

# 2\. 列表
list1 = [10, 20, 30, 40]
del(list1[0])
print(list1)  # [20, 30, 40]

max()

# 1\. 字符串
str1 = 'abcdefg'
print(max(str1))  # g

# 2\. 列表
list1 = [10, 20, 30, 40]
print(max(list1))  # 40

min()

# 1\. 字符串
str1 = 'abcdefg'
print(min(str1))  # a

# 2\. 列表
list1 = [10, 20, 30, 40]
print(min(list1))  # 10

range()

# 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):
    print(i)

# 1 3 5 7 9
for i in range(1, 10, 2):
    print(i)

# 0 1 2 3 4 5 6 7 8 9
for i in range(10):
    print(i)

注意：range()生成的序列不包含end數(shù)字购岗。

enumerate()

• 語法

enumerate(可遍歷對象, start=0)

注意：start參數(shù)用來設(shè)置遍歷數(shù)據(jù)的下標(biāo)的起始值，默認為0门粪。

• 快速體驗

list1 = ['a', 'b', 'c', 'd', 'e']

for i in enumerate(list1):
    print(i)

for index, char in enumerate(list1, start=1):
    print(f'下標(biāo)是{index}, 對應(yīng)的字符是{char}')

容器類型轉(zhuǎn)換

1 tuple()

作用：將某個序列轉(zhuǎn)換成元組

list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}

print(tuple(list1))
print(tuple(s1))

2 list()

作用：將某個序列轉(zhuǎn)換成列表

t1 = ('a', 'b', 'c', 'd', 'e')
s1 = {100, 200, 300, 400, 500}

print(list(t1))
print(list(s1))

3 set()

作用：將某個序列轉(zhuǎn)換成集合

list1 = [10, 20, 30, 40, 50, 20]
t1 = ('a', 'b', 'c', 'd', 'e')

print(set(list1))
print(set(t1))

注意：

1. 集合可以快速完成列表去重
2. 集合不支持下標(biāo)

推導(dǎo)式

列表推導(dǎo)式

作用：用一個表達式創(chuàng)建一個有規(guī)律的列表或控制一個有規(guī)律列表喊积。

列表推導(dǎo)式又叫列表生成式。

1.1 快速體驗
需求：創(chuàng)建一個0-10的列表玄妈。

while循環(huán)實現(xiàn)

# 1. 準(zhǔn)備一個空列表
list1 = []

# 2. 書寫循環(huán)乾吻，依次追加數(shù)字到空列表list1中
i = 0
while i < 10:
    list1.append(i)
    i += 1

print(list1)
for循環(huán)實現(xiàn)
list1 = []
for i in range(10):
    list1.append(i)

print(list1)
列表推導(dǎo)式實現(xiàn)
list1 = [i for i in range(10)]
print(list1)

1.2 帶if的列表推導(dǎo)式
需求：創(chuàng)建0-10的偶數(shù)列表

#方法一：range()步長實現(xiàn)
list1 = [i for i in range(0, 10, 2)]
print(list1)
#方法二：if實現(xiàn)
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)

1.3 多個for循環(huán)實現(xiàn)列表推導(dǎo)式
需求：創(chuàng)建列表如下：

[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
代碼如下：

list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)

字典推導(dǎo)式

思考：如果有如下兩個列表：

list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']
如何快速合并為一個字典？

答：字典推導(dǎo)式

字典推導(dǎo)式作用：快速合并列表為字典或提取字典中目標(biāo)數(shù)據(jù)拟蜻。

2.1 快速體驗

創(chuàng)建一個字典：字典key是1-5數(shù)字绎签，value是這個數(shù)字的2次方。
dict1 = {i: i**2 for i in range(1, 5)}
print(dict1)  # {1: 1, 2: 4, 3: 9, 4: 16}
將兩個列表合并為一個字典
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']

dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)
提取字典中目標(biāo)數(shù)據(jù)
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}

# 需求：提取上述電腦數(shù)量大于等于200的字典數(shù)據(jù)
count1 = {key: value for key, value in counts.items() if value >= 200}
print(count1)  # {'MBP': 268, 'DELL': 201}

集合推導(dǎo)式

需求：創(chuàng)建一個集合酝锅，數(shù)據(jù)為下方列表的2次方诡必。

list1 = [1, 1, 2]
代碼如下：

list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1)  # {1, 4}

注意：集合有數(shù)據(jù)去重功能。