切片，字元，列表，元組，字典，集合

===============================

一、python的索引

（1）定義：我們可以直接使用索引來訪問序列中的元素， （2）索引可分為：正向索引和負向索引

正向索引：從0開始

負向索引：從-1開始

 （3）Python中的序列，包括字串(String)、列表(List)、元組(Tuple)

二、切片

（1）

定義：切片是指對操作的物件擷取其中一部分的操作，字串、列表、元組都支援 切片操作。 （2） 切片的語法：[ 開始索引: 結束索引值 : 步長]   步長不能為0，且預設值為1 （3）切片中包含開始值，不包含結束值 （4）range 函式 案例：

print(list(range(10)))
print(list(range(3,10)))
print(list(range(1,11,2)))
print(list(range(0,11,2)))

（5）案例：

s='abcdefghijk'
print(s[1])#根據正向索引取值  1就是表示b  #索正引從0開始
print(s[-2]) #根據負向索引取值  -2就是表示j  #負索引從-1開始
print( s[1:4]) #bcd 根據正向索引取值 ，包含索引1，2,3
print(s[:]) #  顯示所有abcdefghijk
print(s[2:] ) #cdefghijk  從索引2開始取空值表示所有
print(s[::-1] ) #反轉 #kjihgfedcba
print(s[2:6:2] ) #ce   2 是步長
print(s[-2:-7:-2] ) #jhf  負向索引取值
print( s[:5]) #abcde

 

 ==================================

字元：

（1）字串的定義：用單引號或雙引號括起來，（英文）

（2）型別：<class 'str'>   

案例： s='abcdefghijk'

c="abcdefghijk"
print(type(s))#<class 'str'>
print(type(c)) #<class 'str'>
 

（3）str 轉換成字元型別

m=1
print(type(m)) #<class 'int'>
print(type(str(1))) #<class 'str'>
（4）常見的函式：

n='Abc'
x='xyz'
y="1234"
z="123abc"
#1、capitalize()：首字元大寫
# print(s.capitalize()) #Abcdefghijk
# #2.標題化首個字母大寫
# print(s.title())#標題化首個字母大 #Abcdefg  Hi  Jk
# 3.count()：統計具體字元出現的次數
# print(s.count("a")) #3
# # 4.join()：把集合中的字元按自定義的分隔符連線在一起
# print(', '.join(s))
# # 5.split()：把字串通過指定識別符號進行分割
# print(s.split("e"))
# 6.strip()：刪除字串開頭和結尾有a或b的字元
# print(s.strip("a"))
# 7.lstrip(ab)：刪除字串開頭有a序列字元
# print(s.lstrip("a")) #bacdefaghijka
# # 8.刪除字串結尾有a序列字元
# print(s.rstrip("a")) #abacdefaghijk
# # 9.endswith()：判斷字串是否以什麼結束
# print(s.endswith("a")) #True 對
# print(s.endswith("b")) #False 錯
# 10、startswith()：判斷字串是否以什麼開始
# print(s.startswith("ab")) #True
# 11.find()/rfind()：字串查詢find()是開始查，rfind()從右邊開始查，結果 顯示下標左邊
# print(s.find("c")) #3  從左邊開始找，找到第一個就結束，顯示索引位
# print(s.rfind("c")) #8 從右邊開始找，找到第一個就結束，顯示索引位
# print(s.rfind("*")) #-1  查詢不存在的資料
# print(s.find("*")) #-1   查詢不存在的資料
#11、replace()：replace(substring,newstring,max) substring表示被替換的字
# print(s.replace('a','v')) #vbvcdefvcghijkv  替換了所有的資料
# print(s.replace('a','v',2)) #vbvcdefacghijka 2表示替換次數從左往右替換
# 12、lower()：方法轉換字串中所有大寫字元為小寫
# print(c.lower()) #abcd
#13upper()：將字串中的所有小寫字元轉換為大寫字母輸出
# print(x.upper()) #XYZ
# #isdigit()：判斷字串中是否全為數字
# print(y.isdigit()) #True
# print(z.isdigit()) #False
# # isalpha()：判斷字串中是否全為字母
# print(c.isalpha()) #True
# print(z.isalpha()) #False
#isalnum()：判斷字串當中是否全都為數字，全為字母，或者數字字母組合 返回布林值：True和False 如果有特殊符號就是否
# print(x.isalnum()) #True
# print(y.isalnum()) #True
# print(z.isalnum()) #True
#istitle()：判斷字串中首字母是否為大寫，其他是否為小寫，其他不為小寫則為否
# print(c.istitle()) #False
# print(n.istitle()) #True
# isupper()/islower():is判斷是否展示為都是大寫或者都是小寫
print(c.isupper()) #True
print(x.islower()) #True
print(n.islower()) #False
print(n.isupper()) #False

 ========================================

列表：

（1）定義：列表（list）是一組有序儲存的資料，也是python常見的序列之一，

（2）單詞：list

（3）符號：[]

（4）字元型別：<class 'list'>

（5）定義列表的兩種方法：

方法一：list1 = [1,2,3,4] #直接通過[]進行定義

案例：
a=[1,2,3,4]
print(type(a)) #<class 'list'>

  方法二：list2 = list('1234') #使用list()方法進行定義 案例：

b='1234'
print(type(b)) #<class 'str'>
print(list(b)) #['1', '2', '3']
print(type(list(b))) #<class 'list'>

(6)列表操作   
1、通過索引賦值：格式 列表名[索引]='新值'
2、append函式：新增一個元素
3、extend函式：連線兩個列表

4、insert(index,value)函式：在指定位置插入一條資料

5、remove函式：移除元素

6、del 索引刪除值

7、index函式：在列表中查詢元素所對應的索引值

8、sort函式：實現列表的升序排列

9、sorted函式：實現降序排列

10、reverse函式：列表元素反轉

11、pop函式：

=======================

案例：

1、通過索引賦值：格式 列表名[索引]='新值'
案例1：

a=[1,2,3,4，5]
a[2]='v'
print(a) #[1, 2, 'v', 4, 5]

案例2：

a=[1,2,3,4,5]
a[2:]='v'
print(a) #[1, 2, 'v']

2、append函式：新增一個元素
預設新增在最後一位
案例：

a=[1,2,3,4,5]
a.append("v")
print(a)

3、extend函式：連線兩個列表
案例：

a=[1,2,3,4,5]
b=[7,8,9,10]
a.extend(b)
print(a) #[1, 2, 3, 4, 5, 7, 8, 9, 10]
print(b) #[7, 8, 9, 10]

4、insert(index,value)函式：在指定位置插入一條資料

插入的資料的原來的資料，往後移動一位，在插入

案例1：在索引範圍

a=[1,2,3,4,5]
a.insert(2,'v')
print(a)
案例2：超出索引位，新增在末尾

a=[1,2,3,4,5]
a.insert(10,'v')
print(a) #[1, 2, 3, 4, 5, 'v']
案例3：插入負向索引

a=[1,2,3,4,5]
a.insert(-2,'v')
print(a ) #[1, 2, 3, 'v', 4, 5]

5、remove函式：移除元素

案例1：刪除存在的值

a=[1,2,3,4,5]
a.remove(4)
print(a)
案例2：刪除不存在的值，直接報錯

a=[1,2,3,4,5]
a.remove(6)
print(a)
案例3：刪除多個值的情況，從左往右刪除

a=[1,2,5,3,4,5]
a.remove(5)
print(a)

6、del 索引刪除值

 案例:

a=[1,2,5,3,4,5]
del a[2]
print(a) #[1, 2, 3, 4, 5]

7、index函式：在列表中查詢元素所對應的索引值

案例：

a=[1,2,5,3,4,5]
print(a.index(3)) #3

8、sort函式：實現列表的升序排列

案例1：

a=[1,8,2,6,3,4,5]
a.sort()
print(a)
案例2：

a=[1,8,2,6,3,4,5,"a"]
a.sort()
print(a)報錯：字母和數字不能同時進行排序

9、sorted函式：實現降序排列

案例：

a=[1,8,2,6,3,4,5]
print(sorted(a,reverse=True)) #降序
print(sorted(a,reverse= False))#升序

10、reverse函式：列表元素反轉

案例:

a=[1,8,2,6,3,4,5]
a.reverse()
print(a)

11、pop函式：

案例1：預設刪除

a=[1,8,2,6,3,4,5]
a.pop()
print(a)
案例2：根據索引刪除

a=[1,8,2,6,3,4,5]
a.pop(1)
print(a) #[1, 2, 6, 3, 4, 5]


=======================
元組：
定義：

1、定義：元組（tuple）是Python中常用的一種資料結構。元組由不同的元素組成， 每個元素可以儲存不同型別的資料，如字串、數字、甚至元組。元組是'防寫' 的，即元組中元素作為一個整體，建立後不能再做任何修改操作。

2、符號：（）
3、型別：<class 'tuple'>
4、 單詞：tuple
5、特殊情況：當出現一位資料時，加上一個逗號

a=(1)
print(type(a)) #<class 'int'>
6、元組是不可變，有序
7、元組的實戰
（1）通過索引取值
案例：

a=(1,2,3)
print(a[1])
（2）要修改元組，就要將元組通過list改成列表，在修改，修改好在通過轉回元組

a=(1,2,3,4,5,6)
print(type(a))#<class 'tuple'>
b=list(a)   #通過list將元組轉換成列表
print(type(b)) #<class 'list'>
print(b)
b.append(8) #通過列表中函式操作
print(b)
c=tuple(b)#通過tuple將列表轉換成元組
print(type(c)) #<class 'tuple'>
print(c)
（3）元組和列表的區別？

相同： a、都是序列型別的容器物件，可以存放任何型別的資料 b、支援切片、迭代等操作 不同： a、list 是可變的物件，元組tuple是不可變的物件 b、tuple不可變，所以使用tuple可以使程式碼更安全 ========================================== Python中的字典 1、定義： 字典（dict）是另一種可變容器模型，且可儲存任意型別物件 2.鍵值對的形式存在 字典的每個鍵值key：value對用冒號 : 分割 3、符號：{ } 4、字元型別：<class 'dict'> 5、定義字典： （1）直接定義{} 案例：

d={'name':"wd",'age':'18'}
（2）通過dict 轉換成字典
案例

a=[('name',"wd"),('age','18')]
print(type(a)) #<class 'list'>
zd=dict(a)  
print(type(zd))  #<class 'dict'>
print(zd)  #{'name': 'wd', 'age': '18'}

6、字典的實戰 （1）新增一個鍵值對 案例一：新增新的鍵值，預設新增在最後

d={'name':"wd",'age':'18'}
d ['sex']=' 女'
print(d)

案例二：已存在的鍵值 #鍵不變修改值

d={'name':"wd",'age':'18'}
d ['age']=' 20'
print(d) 
（2）取出鍵返回列表

d={'name':"wd",'age':'18'}
print(d.keys())
（3）取出值返回列表

d={'name':"wd",'age':'18'}
print(d.values()) #dict_values(['wd', '18'])
（4）取出具體鍵的值

d={'name':"wd",'age':'18'}
print(d['age']) #18
（5）字典新增元素setdefault（）
案例1:不存在的資料，直接新增

d={'name':"wd",'age':'18'}
d.setdefault("sex","女")
print(d)

案例2:存在的資料，預設值的優先順序小於字典本身

d={'name':"wd",'age':'18'}
d.setdefault("age",'20')
print(d)

（6）del  刪除字典

d={'name':"wd",'age':'18'}
del (d)   字典不存在

  7、刪除指定的鍵，連同值也刪除

d={'name':"wd",'age':'18'}
del d['name']
print(d)

8、字典的遍歷：for...in...遍歷字典
案例：

d={'name':"wd",'age':'18'}
for k in d:
    print(k,d[k])

9、通過for迴圈獲取所有鍵

d={'name':"wd",'age':'18'}
for k in d:
    print(k)

10、使用items()完成遍歷

d={'name':"wd",'age':'18'}
for k,v in d.items():
    print(k,v)
11、pop(key)函式，刪除指定鍵並返回刪除的值
案例1：刪除後的內容

d={'name':"wd",'age':'18'}
d.pop("name")
print(d)
案例2：打印出刪除內容

d={'name':"wd",'age':'18'}
print(d.pop("name")) #wd

12、clear()清空字典所有項

d={'name':"wd",'age':'18'}
d.clear()
print(d) #返回一個{}空

13、get(key)方法,通過key獲取值,當鍵不存在,返回None
案例1：get獲取存在的值

d={'name':"wd",'age':'18'}
print(d.get('age'))#18

案例2：get獲取不存在的值 ，結果是none值

d={'name':"wd",'age':'18'}
print(d.get('a')) 

14、fromkeys函式可以給具體的鍵指定值

（1）快速生成字典，鍵
print({}.fromkeys(['name','age']))
（2）快速生成字典鍵和值

print({}.fromkeys(['name','age'],"s"))
（3）已經存在的字典，通過fromkeys重新賦值

d={'name':"wd",'age':'18'}
print(d.fromkeys(['name','age'],"s"))

15、popitem函式隨機返回並刪除字典中的鍵值對(一般刪除末尾對)
案例：

d={'name':"wd",'age':'18'}
print(d.popitem())

16、update函式利用一個字典更新另外一個字典
案例1：

d={'name':"wd",'age':'18'}
c={"sex":'男'}
d.update(c)
print(d)
print(c)
17、copy複製字典

d={'name':"wd",'age':'18'}
s=d.copy()
print(s)
print(d)

==========================================
集合

（1）集合是不同元素的無序集合，與序列型別不同，集合是沒有切片操作

（2）單詞：set  可變集合  ，frozenset  不可變集合

a .可變集合：集合裡面的元素是可以發生改變，集合中的資料可以修改

b.不可變集合：集合彙總的元素是不可以發生變化

（3）集合：最重要的功能就是去重  (4)集合是無序，集合的元素是不重複的 （5）字元型別：可變集合：<class 'set'>   一、可變集合 （1）對重複的資料，進行去重 案例1：對列表進行去重  

a=[1,2,5,2,6,2,8]
b=set(a)
print(b) #{1, 2, 5, 6, 8}
print(type(b))

案例1：對字元進行去重

a='abcdssakm'
b=set(a)
print(b) #{'b', 's', 'm', 'c', 'k', 'a', 'd'}
print(type(b))
二、可變集合操作

（1）add新增元素 ，位置隨機新增

a=[1,2,5,2,6,2,8]
b=set(a)
b.add("dd")
print(b)
（2）remove 刪除元素

a=[1,2,5,2,6,2,8]
b=set(a)
b.remove(8)
print(b)
（3）pop 刪除 #

#把最前面這個給刪除了

a=[1,2,5,2,6,2,8]
b=set(a)
b.pop()
print(b)
（4）clear（） 清除，返回set空集合

a=[1,2,5,2,6,2,8]
b=set(a)
b.clear()
print(b)
5、update 新增元素到集合中

a=[1,2,5,2,6,2,8]
b=set(a)
b.update("r")
print(b)

6、copy  複製集合

a=[1,2,5,2,6,2,8]
b=set(a)
c=b.copy()
print(b)
print(c)
======================================

不可變集合frozenset 1、不能新增，修改，只能複製
2、型別：<class 'frozenset'> 3,單詞:frozenset 4、copy 不可編輯和

案例：

a=[1,2,5,2,6,2,8]
b=frozenset(a)
c=b.copy()
print(b)
print(c)

======================================