11.8 python之字元型別

胡豪發表於2024-11-08

一、索引

索引在公司中一般也叫下標,或角標

定義:可我們可以直接使用索引來訪問序列中的元素,同時索引可分為正向索引和負向索引兩種,而切片也會用到索引,如下圖:

Python中有序列:字元,列表,元組

無序:集合

正向索引:從0開始

負向索引:-1開始

二、切片

定義:切片是指對操作的物件擷取其中一部分的操作,字串,列表,元組都支援切片操作

切片的語法:【開始索引:結束索引 :步長】

備註:顯示結果:包含開始值,不包含結束值

str="abcdefghigklmn"
print(str[1:3]) # 結果:bc
print(str[0]) #結果:a
print(str[:])#print(str[:])
print(str[3:]) #print(str[:])
print(str[::-1]) #nmlkgihgfedcba 反轉(重點)
print(str[::1]) #abcdefghigklmn
print(str[1:8:2]) #bdfh
print(str[-1:-8:-2]) #nlgh
print(str[0:-1]) #開始到倒數第二個 #abcdefghigklm
print(str[2:3]) #c

字串:

str="abcdefcnamceac"
str1="abc"
str2="EFG"
str3="123"
str4="abc123"
str5="Abc789"
print(str.capitalize()) #首個字元大寫 # Abcdef
print(str.title()) #首個字元大寫 Abcdef
print(str.count('a')) # 統計字元個數 #2個
print(' '.join(str)) #把集合中字元按照符號分隔 #a/b/c/d/e/f/n/a/m/e
print(str.split("c")) # 透過制定的內容進行表示分割 #['ab', 'defname']
print(str.strip("a")) #刪除字元的開頭和結尾的字元 #bcdefname
print(str.lstrip("a")) #刪除字元的開頭字元 #bcdefnamea
print(str.rstrip("a")) #刪除字元的末尾字元 #abcdefname
print(str.startswith("a")) #判斷字串是否以某個字元開頭 #True
print(str.startswith("b")) #判斷字串不是以某個字元開頭 #False
print(str.endswith("a")) #判斷字串是以某個字元結尾 #True
print(str.endswith("b")) #判斷字串不是以某個字元結尾 False
print(str.find("c")) #find是從左邊開始查 #2
print(str.rfind("c")) #rfind是從右邊開始查 #9
print(str.replace("c","123")) #替換,"c"是原值,"123"是新值
print(str.replace("c","123",2)) #指定替換的次數,是從左往右替換
print(str1.upper()) #將字元所有的小寫字元轉換成大寫字母輸出
print(str2.lower()) #將字元所有的大寫字元轉換成小寫字母輸出
print(str.isdigit()) #判斷字串中是否全是數字 #False
print(str3.isdigit()) #判斷字串中是否全是數字#True
print(str4.isalpha()) #判斷字串中是全是字母#False
print(str4.isalnum()) ##判斷字串中是全是字母或全是數字或數字和字母組合 #True
print(str.istitle()) #判斷首個字母是否大寫 #False #必須是隻有首個字元大小,其他字母為小寫
print(str5.istitle()) # True
print(str1.islower()) #判斷字元是否都是小寫
print(str2.isupper())#判斷字元是否都是大寫

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

列表:

列表

型別:<class 'list'>
符號:[]
定義:列表list 是一組有序儲存的資料,也是python常見的序列值一、序列中的每個元素都分配一個索引,第一個元素的索引是0,第二個元素的索引是1,依次類推,序列都可以進行操作包括索引,切片
定義列表的方法有兩種:
方法一:list1=[1,2,3,4] #直接透過[]進行定義
方法二:list2=list('12345) #直接透過list轉換
案例1:
list=[1,2,3,4,5]
print(type(list))
案例2:
str="abc"
print(type(str))
s=list(str)
print(type(s))
1、列表中索引和切片

(1)透過索引新增值(覆蓋原有值)

案例:

list1=[1,2,3,4,5]
list1[1]="s"
print(list1) #結果:[1, 's', 3, 4, 5]
(2)list1=[1,2,3,4,5]
list1[2:]="我們暴富15班"
print(list1)
結果:[1, 2, '我', '們', '暴', '富', '1', '5', '班']
2、列表中的函式

(1) append 新增元素 預設新增在最後一位

案例:

list1=[1,2,3,4,5]
list1.append("name")
print(list1)
(2)extend :連線兩個列表

list1=[1,2,3,4,5]
list2=[6,7,8,9,10]
list1.extend(list2)
print(list1) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list2)#[6, 7, 8, 9, 10]
(3)insert( index, value) 在指定位置插入資料
list1=[1,2,3,4,5]
list1.insert(2,"t")
print(list1) 結果:[1, 2, 't', 3, 4, 5]
(4)remove刪除列表中的值,從左開始刪除,只刪除第一個
list1=[1,2,3,4,5]
list1.remove(3)
print(list1)
(5)del 索引刪除值
list1=[1,2,3,4,3,5]
del list1[3]
print(list1) 結果:[1, 2, 3, 3, 5]

(6)index 在列表中找元素所對飲過的索引值
list1=[1,2,3,4,3,5] #索引位是3
print(list1.index(4))
(7)sort 函式,實現列表的升序排列
list1=[9,2,0,4,3,5]
list1.sort()
print(list1) #結果:[0, 2, 3, 4, 5, 9]
(8)sorted 排序
list1=[9,2,0,4,3,5]
print(sorted(list1,reverse=True)) #降序 #[9, 5, 4, 3, 2, 0]
print(sorted(list1,reverse=False)) #升序 # #[0, 2, 3, 4, 5, 9]
(9)reverse 函式:列表元素反轉
list1=[9,2,0,4,3,5]
list1.reverse()
print(list1)
(10)pop 函式
預設移除列表中最後一個元素,並返回元素值
list1=[9,2,0,4,3,5]
list1.pop()
print(list1) #[9, 2, 0, 4, 3]

====================================
元組
元組不可變
定義:元組是python中一種資料結構,元組由不同的元素組成,每個元素可儲存不同型別的資料;如字串,數字,甚至元組,
元組是“防寫”的,即元組中元素作為一個整體,建立後不能做任何修改操作。
a=(1,2,3)
print(type(a))
print(a)

當出現一個字元時,加上逗號,(就變成了元組)
b=(1,)
print(type(b))
print(b)

元組函式運用:
(1)index 索引
a=(1,2,3)
print(a.index(2))
conct 統計
print(t2.count(1)) # 統計元素
(2)元組需要修改,只能將元組轉換成列表,使用列表的函式操作,列表操作完在轉換成元組

a=(1,2,3)
print(type(a))
b=list(a) #透過list將元組轉換成列表
print(type(b))
print(b)
b.insert(2,"s") #透過列表中的函式取操作轉換後的元組
print(b)
yz=tuple(b) #透過tuple 將列表轉換成元組
print(type(yz))
print(yz) #列印元組
(3)元組轉換列表
a=(1,2,3)
print(type(a))
b=list(a)
print(type(b))
(4)列表轉換成元組
s=[1,2,3]
print(type(s))
c=tuple(s)
print(type(c))
print(c)

(5)元組和列表的區別:
相同:
1、都是有序,
2、都支切片、迭代等操作
不同:
1、list是可變物件,元組tuple是不可變物件
2、tuple不可變,使用tuple編寫的程式碼更安全
3、列表是【】,元組是()
4、列表的字元型別:list ,元組的字元型別:tuple

====================================
字典:
字典的字元型別 <class 'dict'>
符號:{}

1、字典(dict)是一種可變容器模型,且可儲存任意型別物件
2、字典的每個鍵,值 key,value 鍵值對形式
3、鍵值用:分割,每個鍵值對之間用逗號分隔
4、整個字典用{}包含
5、字典鍵唯一,值不是唯一的

定義字典的方式:

方法一:透過{}定義字典
d={'name':'hz','age':18}
print(type(d))

方法二:透過dict來轉換成字典
c=[('a',1),('b',2),('c',3)]
print(type(c))
cc=dict(c)
print(type(cc))
print(cc)

字典中常見的函式:
1、新增一個鍵值對
(1)新的鍵和值
s={'a': 1, 'b': 2, 'c': 3}
s["d"]=4
print(s)
(2)新增已經存在的鍵值對 (鍵不變,值改變)
s={'a': 1, 'b': 2, 'c': 3}
s["c"]=4
print(s) # 說明插入的值比預設的值的優先順序高
2、使用keys取出所有鍵返回列表
s={'a': 1, 'b': 2, 'c': 3}
print(s.keys()) 結果:dict_keys(['a', 'b', 'c'])

3、使用values取出所有值返回列表
s={'a': 1, 'b': 2, 'c': 3}
print(s.values()) 結果:dict_values([1, 2, 3])

4、取出具體鍵的值
s={'a': 1, 'b': 2, 'c': 3}
print(s['c'])

5、字典中預設新增元素 setdefault
(1)當新增的鍵值都顯示(不存在)
s={'a': 1, 'b': 2, 'c': 3}
s.setdefault("d",4)
print(s)
(2)插入存在的鍵值,新值不會覆蓋原值(預設值優先順序要低於字典中的鍵值)

s={'a': 1, 'b': 2, 'c': 3}
s.setdefault("c",4)
print(s) #{'a': 1, 'b': 2, 'c': 3}

6、 clear 清空字典
s={'a': 1, 'b': 2, 'c': 3}
s.clear()
print(s) #結果:{}

7、刪除字典中指定的鍵,連同值也刪除
案例1
s={'a': 1, 'b': 2, 'c': 3}
del s["b"]
print(s) #{'a': 1, 'c': 3}
案例2:
s={'a': 1, 'b': 2, 'c': 3}
del s["b"]
del s['c']
print(s)

8、for迴圈遍歷字典,
(1)遍歷所有的鍵
案例:
s={'a': 1, 'b': 2, 'c': 3}
for i in s:
print(i,end="")
(2)
遍歷所有的鍵和值
s={'a': 1, 'b': 2, 'c': 3}
for i in s:
print(i,s[i])
(3)使用items()完成遍歷
s={'a': 1, 'b': 2, 'c': 3}
for k,v in s.items():
print(k,v)

8、pop 刪除函式
刪除指定鍵並返回刪除的值
s={'a': 1, 'b': 2, 'c': 3}
print(s.pop("a")) #1

9、get(key)方法,透過key獲取值,當鍵不存在,返回none
案例1:
s={'a': 1, 'b': 2, 'c': 3}
print(s.get("b")) #2
案例2:

s={'a': 1, 'b': 2, 'c': 3}
print(s.get("d")) ##None

10、popitem 函式隨機刪除返回刪除字典中的鍵值對(一般預設刪除末尾的鍵值)
s={'a': 1, 'b': 2, 'c': 3}
v=s.popitem()
print(v) # ('c', 3) 刪除的鍵值
print(s) #

11、update函式利用一個字典更新另一個字典
案例1
s={'a': 1, 'b': 2, 'c': 3}
c={'d': 4, 'e': 5}
s.update(c)
print(s) #{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
print(c) #{'d': 4, 'e': 5}
案例2 有重複鍵,顯示覆蓋的字典中的值
s={'a': 1, 'b': 2, 'c': 3}
c={'a': 4, 'e': 5}
s.update(c)
print(s)
print(c)
12、copy函式複製字典
案例1:
s={'a': 1, 'b': 2, 'c': 3}
v=s.copy()
print(v)
13、fromkeys 函式可以給集體鍵指定值
(1)快速建立字典
print({}.fromkeys(["name",'age'])) #{'name': None, 'age': None}
(2)快速建立字典鍵和值
print({}.fromkeys(["name",'age'],"1"))

====================================
集合:最重要功能是去重
第一種:可變集合 set
第二種:不可變集合 frozenset
字元型別:<class 'set'>

案例:
1、對列表去重
list=[1,2,3,6,4,4,2,8]
print(type(list)) #<class 'list'>
s=set(list)
print(type(s))
print(s)

2、對字元去重
a="abcdasmoa"
s=set(a)
print(type(s))
print(s)
3、函式的用法
(1)add 集合中添引數
list=[1,2,3,6,4,4,2,8]
s=set(list)
s.add("a")
print(s)
(2)remove 刪除具體的引數
list=[1,2,3,6,4,4,2,8]
s=set(list)
s.remove(3)
print(s) #{1, 2, 4, 6, 8}

(3)pop 刪除資料
list=[1,2,3,6,4,4,2,8]
s=set(list)
s.pop()
print(s)

(4)clear 清除
list=[1,2,3,6,4,4,2,8]
s=set(list)
s.clear()
print(s) #set()

(5)copy 複製

list=[1,2,3,6,4,4,2,8]
s=set(list)
k=s.copy()
print(k)
(6)update 將兩個集合合併
list=[1,2,3,4,4,4,5,7,8,10,9,1]
s=set(list)
print(s)
list6=["a","b",1]
v=set(list6)
s.update(v)
print(s) #{1, 2, 3, 4, 5, 7, 8, 9, 10, 'b', 'a'}

===============================
不可變結合:
frozenset

1、copy不可變集合
list=[1,2,3,6,4,4,2,8]
s=frozenset(list)
k=s.copy()
print(k) #frozenset({1, 2, 3, 4, 6, 8})

===================================
字元,列表,元組,字典,集合 (可變集合,不可變集合)
作業:
1、python有哪些字元型別?
2、列表,元組區別?
3、字元,列表,元組,字典,集合的瞭解?

相關文章