Python_基礎資料型別-有解無憂

一，首先介紹一下變數

1. 變數是什么

在Python中，變數的概念基本上和初中代數的方程變數是一致的，

2. 變數命名規則

由數字、字母、下劃線組成
不能以數字開頭
要具有描述性
要區分大小寫
禁止使用python的關鍵字(在pycharm中關鍵字變數字體顏色會改變)
不能使用漢字或拼音
變數的推薦寫法
7.1 駝峰體(類名推薦駝峰)
7.2 下劃線(官方推薦)

3. 常量

變數名大寫就是常量，

二，基礎資料型別介紹

1， int

數字型別，不可變，可哈希，用于比較和計算，
python3除法回傳的是float,浮點數（小數）
不可變資料型別之一

2，bool

布林值，用于判

True - 真
非空就是True，如：1，‘字串’，[串列]，(元組,) 等資料型別不為空就是真，
False - 假
為空就是False，如：0，’’，[]，()

3，str

什么是字串？

python只要是用引號（''，""，""""""）引起來的就是字串
字串用于存盤少量資料，不可變資料型別之一，

str的索引、切片、步長

索引，index
注意：索引的時候不可以超出字串的索引值，
切片
切片的時候可以超出索引值，顧頭不顧尾，
print(變數名[起始位置：終止位置]) 顧頭不顧尾
print(變數名[:]) # 默認是從頭到尾
步長
決定查找的方向（+ -）
決定查找時查到的步子
步長默認為1
[起始位置：終止位置：步長]

例：

# 從左向右排a = "0123456"
# 從左向右排a = "-7-6-5-4-3-2-1"
a = "風yu雷dian"
print(a[4]) # ｄ
print(a[-4]) # a
name = "東方不敗,火云邪神,未來戰士,審判天使,鋼鐵大俠"
print(name[0:14:2])
# 東不,云神未戰
print(name[-4:-6:-1]) 
# 鋼,
print(name[-7:-12:-2])
# 天審士 
print(name[::-1]) 
# 俠大鐵鋼,使天判審,士戰來未,神邪云火,敗不方東

字串的方法

upper() —— 全部大寫

name = "qwer"
a = name.upper()  # 全部大寫
print(a)
print(name)

lower() —— 全部小寫

name = "QWER"
a = name.lower()   # 全部小寫
print(name)
print(a)

str.capitalize() —— 首字母大寫
str.title() —— 每個單詞的首字母大寫
str.swapcase() —— 大小寫轉換，字串中大變小，小變大

name = 'qwer,asdf'
a = name.capitalize()
print(name)
print(a)

b = name.title()
print(name)
print(b)

c = name.swapcase()
print(name)
print(c)
結果：
qwer,asdf
Qwer,asdf
qwer,asdf
Qwer,Asdf
qwer,asdf
QWER,ASDF

str.center(數字,“分割符號”) —— 居中，填充

st = '真帥！'
a = st.center(30,"-")
print(st)
print(a)

結果：
真帥！
-------------真帥！--------------

startswith(“判斷字符”，索引開頭，索引結尾) —— 以什么開頭 – 回傳的是布林值

endswith(“判斷字符”，索引開頭，索引結尾) —— 以什么結尾 – 回傳的是布林值

name = "qwertyuiop"
print(name.startswith('e',2,3))  # 以什么開頭 -- 回傳的是布林值
print(name.endswith("x",1,4))    # 以什么結尾 -- 回傳的是布林值

count(“字符”，索引) —— 統計，計數

name = "qwetyuitrewasdfgh"
print(name.count("w",8))      # 統計,計數 區分大小寫，8為索引到位置，從左到右計數，默認搜索全部
結果：1

strip() —— 脫默認脫(脫頭尾兩端的空格,換行符\n,制表符\t)

pwd = " ez   "
a = pwd.strip()   # 脫 默認脫(脫頭尾兩端的空格,換行符\n,制表符\t)
print(a)
pwd = "qweruytreqw"
a = pwd.strip("qw")  # 去除頭尾兩端指定的內容,"al"不分順序
print(a)
結果：
ez 
eruytre

split() —— 分割(默認空格,換行符\n,制表符\t)

“分割符”.join(list) —— 拼接,將串列轉換成字串

name = "qwe_asd_cc_r"
a = name.split("_")        # 分割(默認空格,換行符\n,制表符\t)
print(a)                   
a = name.split("_",2)      # 指定分割次數 
print(a)
結果：回傳的是串列型別
['qwe', 'asd', 'cc', 'r']
['qwe', 'asd', 'cc_r']


lis = ['qwe', 'asd', 'cc_r']
b = ",".join(lis)
print(lis)
print(b)
結果：
['qwe', 'asd', 'cc_r']
qwe,asd,cc_r

replace() —— 全部替換

name = "weixiang,qwe,a,b,v,d,e"
a = name.replace(",",".")               # 全部替換
print(a)
a = name.replace(",",".",4)             # 指定替換的次數
print(a)
結果：
weixiang.qwe.a.b.v.d.e
weixiang.qwe.a.b.v,d,e

format"{}" —— 按照位置順序進行填充

name = "{}今年:{}".format("兒子",18)    # 按照位置順序進行填充
print(name)
name = "{1}今年:{0}".format("兒子",18)    # 按照索引進行填充
print(name) # 18今年：兒子
name = "{name}今年:{age}".format(name="兒子",age=18)    # 按照名字進行填充
print(name)

print(str.fimd(“元素”)) —— 查找通過元素查找索引,查找不到時回傳-1
print(str.index(“元素”)) —— 查找通過元素查找索引,查找不到時就報錯
```
推薦使用find，畢竟報錯看著很難受，
```
isdigit() —— 判斷字串中的內容是否全是阿拉伯數字
isdecimal() —— 判斷字串中的內容是不是十進制數
isalnum() —— 判斷字串中的內容是不是數字，字母，中文
isalpha() —— 判斷字串中的內容是不是字母，中文

isascii() —— 判斷字串中是不是字母數字(3.7以上解釋器中存在)

msg = "wuhuaguo"
print(msg.isdigit())      # 判斷字串中的內容是不是全都是數字(阿拉伯數字)False
print(msg.isdecimal())    # 判斷是不是十進制數False
print(msg.isalnum())      # 判斷是不是數字,字母,中文Ture
print(msg.isalpha())      # 判斷是不是字母,中文Ture
print(msg.isascii())      # 判斷是不是字母數字Ture

len() —— 查看資料型別中共有多少個元素

msg = "原諒我這一生不羈放縱愛自由"
print(len(msg)) # 公用的方法: len ，回傳的是數字型別

4，list

什么是串列

串列，list，資料型別之一
儲存da大量的，不同型別的資料
有序，可變，不可哈希
串列的定義：lis = []

串列的索引

串列和字串一樣也擁有索引，但是串列可以修改:

lst = ['張三','李四','趙五','陳六']
print(lst[0])  # 串列中第一個元素
print(lst[1])  # 串列中第二個元素
print(lst[2])  # 串列中第三個元素

串列的切片&步長

切片的用法和步長和字串一樣，顧頭不顧尾，

lst = ["章", "菲", "繡", "花", "魯迅"] 
print(lst[0:3])     # ['章', '菲', '繡'] 
print(lst[:3])      # ['章', '菲', '繡']
print(lst[1::2])    # ['菲', '花'] 也有步長 
print(lst[2::-1])   # ['繡', '菲', '章'] 也可以倒著取 
print(lst[-1:-3:-2])    # 倒著帶步長

串列的增

注意：list和str是不一樣的. lst可以發生改變. 所以直接就在原來的物件上進行了操作

追加模式

append() —— 追加，在串列的末尾進行添加

lst = ["章", "菲", "繡", "花", "魯迅"] 
print(lst)  # ["章", "菲", "繡", "花", "魯迅"] 
lst.append("吃雞") 
print(lst) # ["章", "菲", "繡", "花", "魯迅","吃雞"]

insert(索引，插入內容) —— 插入

lst = ["章", "菲", "繡", "花", "魯迅"] 
lst.insert(1, "許褚")    # 在1的位置插入許褚. 原來的元素向后移動一位
print(lst) # ["章", "許褚","菲", "繡", "花", "魯迅"]

extend([“safas”,“1234”]) —— 迭代添加，可以添加串列

# 迭代添加
lst = ["金志文", "張一山", "苦海無涯"]
lst.extend(["麻花藤", "麻花不疼"])
print(lst) #　["金志文", "張一山", "苦海無涯"，"麻花藤", "麻花不疼"]

串列的刪

pop —— 洗掉，默認洗掉最后一個，可以用索引洗掉

pop有回傳值，是被洗掉的內容，

lst = ["章", "菲", "繡", "花", "魯迅"]
print(repr(lst.pop(2)))    # repr()查看當前資料的原生態
print(lst)  #["章", "菲", "花", "魯迅"]

remove —— 通過元素名稱洗掉
clear() —— 清空，留下的是空串列

lst = ["章", "菲", "繡", "花", "魯迅"] 
print(lst)  # ["章", "菲", "繡", "花", "魯迅"] 
lst.clear()
print(lst) # [s]

del list —— 通過索引，切片，步長洗掉

lst = ["章", "菲", "繡", "花", "魯迅"]
del lst[3] #  ["章", "菲", "繡", "魯迅"] 
del lst[1:4]# ["章","魯迅"]
del lst[1::2] # ['章', '繡', '魯迅']

串列的改

通過索引修改

lst = ["章", "菲", "繡", "花", "魯迅"]
lst[1] = "小野豬"
print(lst) # ["章", "小野豬", "繡", "花", "魯迅"]

通過切片進行修改，默認步長為1，修改的內容必須是可迭代的物件，修改的內容可多可少

lst = ["章", "菲", "繡", "花", "魯迅"]
lst[1:3] = "小野豬" # 默認步長為1
print(lst) # ['章', '小', '野', '豬', '花', '魯迅']
lst[1:5:2] = "小芳","青青草原" # 步長不為1的時候，必須一一對應
print(lst) #　['章', '小芳', '繡', '青青草原', '魯迅']

串列的查

index(“元素”) —— 通過元素查找索引
sort() —— 排序，默認是升序
sort(reverse=True) —— 降序，將升序反轉

reverse() —— 將源資料進行反轉

lst = [1,23,4,5,7,8,9]
lst.reverse()
print(lst)               # 將源資料進行反轉

lst1 = lst[::-1]
print(lst)
print(lst1)              # 不修改源資料進行反轉

for回圈（遍歷查詢）

lst = ["章", "菲", "繡", "花", "魯迅"]
for i in lst:
    print(i)

索引

串列的嵌套

一層一層的查找，[…]視為一個元素

lst1 = ["國際章", "阿嬌", ['汪峰', "國際章", "小蘋果", "小姨"],
["蔡徐坤", ["籃球", "姚明", "林書豪"], ["唱", "鄧麗君", "蔡國慶", "騰格爾"],
["跳", "蔡依林", "羅志祥", "趙四", "社會搖"],
["cnb", "alex", "rimo"]]]
print(lst[-3][-1]) # 騰格爾

5，tuple

python資料型別之一，tuple：有序，不可變；只支持查詢，不支持增刪改，
元組中只有一個元素時：(1,)這才是一個完整的元組

（元組就是一個不可變的串列）

統計 —— count()：統計某個元素出現的次數

tu = (1,2,3,4,5,1,2,1)
print(tu.count(1)) # 3   統計元素在元組中出現的次數

獲取索引 —— index()：通過元素查詢索引

tu = (1,2,3,4,5,1,2,1)
print(tu.index(2)) #  1　通過元素查詢索引

用途：就是將一些非常重要的不可讓人改動的資料放在元祖中，只供查看，

元組的嵌套

tu = (1,2,3,4,(5,6,7,8,("alex","wusir",[1,23,4])))
print(tu[4][4][0]) #　alex

6，dict

python的資料結構之一
字典 —— dict
定義：dic = ｛“鍵”:“值”｝
**作用：**存盤資料，大量，將資料和資料起到關聯作用
字典是可變的資料型別，無序的

所有的操作都通過鍵

# 鍵:必須是不可變的資料型別(可哈希),且唯一   不可哈希就是可變資料型別
# 值:任意
dic = {"10":"蘋果手機", #   鍵  值  對
       "11":"蘋果手機",
       "15”:"小米手機",
       "15":"華為手機",
       (1,):"oppo手機",
       }

字典的增：

暴力添加，字典名[鍵] = 值，有則改，無則添加

dic = {'a': '上天', 'b': ['入地', '通幽'], 'c': '吃飯', 'd': '救苦救難'}
dic["二狗"] = "我的太陽" # 添加的是一個鍵值對
dic["騰格爾"] = ["來自草原的沙塵暴","音樂界的泥石流"]
# 新的鍵如果在字典中沒有，那會添加到最后字典的后面；
# 如果有，那將新值替換舊值

有則不添加，無則添加

dict.setdefaullt(鍵，值)

dic = {'a': '上天', 'b': ['入地', '通幽'], 'c': '吃飯', 'd': '救苦救難'}
dic.setdefault("b",["沿著","江山","起起","伏"]) # 鍵存在，所以不添加
dic.setdefault("武器",["刀","槍","棍","棒","斧"])# 鍵為新，在最后一個鍵值對后面添加
# setdefault 添加分為2步：
# 1，先查看鍵是否在字典
# 2，不存在的時候進行添加

字典的洗掉：

pop(鍵) —— 通過鍵洗掉，具有回傳值

dic = {"1":"上樹","2":"遛狗","3":"開黑","4":"打團"}
dic.pop("1") # 洗掉了  "1":"上樹"  這個鍵值對

clear() —— 清空

dic = {"1":"上樹","2":"遛狗","3":"開黑","4":"打團"}
dic.clear() # 清空該字典，保留空字典

del —— 洗掉

del dict —— 洗掉的是容器

del dict[“鍵”] —— 通過鍵洗掉

dic = {"1":"上樹","2":"遛狗","3":"開黑","4":"打團"}
del dic # 洗掉的是整個字典
del dic["3"] # 只洗掉 "3":"開黑"  這個鍵值對

popitem() —— 隨機洗掉，python3.6版洗掉最后一個鍵值對
popitem回傳的是被洗掉的鍵值對

dic = {}
dic.fromkeys("abc",[])
print(dic)
# {}
print(dic.fromkeys("abc",[]))
# 批量創建鍵值對 {"a":[],"b":[],"c":[]}
dic = dic.fromkeys("abc",[]) # 給批量這個賦值給dic
print(dic)
# {'a': [], 'b': [], 'c': []}
dic["b"] = 11
dic["a"].append(10)
print(dic)
# {'a': [10], 'b': 11, 'c': [10]}

字典的改

字典名[鍵] = 值

# 和字典的暴力添加一樣
dic = {"1":"上樹","2":"遛狗","3":"開黑","4":"打團"}
dic["2"] = "星宿老仙，法力無邊" # 直接定位鍵，修改值

字典名.update(新字典)——在最后一個鍵值對后面，迭代添加

dic = {"1":"上樹","2":"遛狗","3":"開黑","4":"打團"}
dic1 = {"天山派":"星宿老仙，法力無邊","少林":"龍抓手"}
dic.update(dic1)
print(dic) #{'1': '上樹', '2': '遛狗', '3': '開黑', '4': '打團', '天山派': '星宿老仙，法力無邊', '少林': '龍抓手'}
dic1.update(dic)
print(dic1)#{'天山派': '星宿老仙，法力無邊', '少林': '龍抓手', '1': '上樹', '2': '遛狗', '3': '開黑', '4': '打團'}

字典的查

字典名.get(鍵,找不到的換回None)

dic = {"1":"上樹","2":"遛狗","3":"開黑","4":"打團"}
print(dic.get("5")) # 回傳 None
print(dic.get("5","找不到啊")) # 回傳 找不到啊
print(dic.get("2")) # 回傳 遛狗

字典名.setdefault(鍵)

dic = {"1":"上樹","2":"遛狗","3":"開黑","4":"打團"}
print(dic.setdefault("3")) # 回傳開黑
print(dic.setdefault("77")) # 回傳 None
print(dic["4"]) # 也可直接查找，沒有就是報錯

- 字典名.keys() ——所有的鍵，獲取到的是一個高仿串列
- 字典名.values() —— 所有的值，獲取到的是一個高仿串列
- items() —— 鍵值
  - 注意：高仿串列支持迭代，不支持索引
```
dic = {"1":"上樹","2":"遛狗","3":"開黑","4":"打團"}
print(dic.keys()) # 所有的鍵，獲取到的是一個高仿串列
print(dic.valuse()) # 所有的值，獲取到的是一個高仿串列
```

for回圈，回傳的是字典的鍵

dic = {"1":"上樹","2":"遛狗","3":"開黑","4":"打團"}
for i in dic:
    print(i) # 回圈出的是字典的鍵

字典的嵌套

dic = {11:{1:{"秦":"嬴政","秦二世","李斯","商鞅","章邯","蒙恬"},         
                2:{"漢":"劉邦","韓信","衛青","霍去病"}
                3:{"三國":"魏","蜀","吳"}},    
       22:{1:{"歌唱家":{"煉訓":["我和你","彎彎的月亮"]}},         
            2:{"鄧紫棋":["泡沫","喜歡你","天堂","光年之外"]},
            3:{"騰格爾":["隱形的翅膀","卡路里","日不落"]}},    
       33:{1:{"蔡徐坤":{"唱":["雞你太美"],"跳":["鋼管舞"],"rap":["大碗面"],"籃球":("NBA形象大使")}},  
            2:{"JJ":{"行走的CD":["江南","曹操","背對背擁抱","小酒窩","不潮不花錢"]}},         
            3:{"Jay":{"周董":["徑訓臺","雙節棍","霍元甲"]}}},    
       44:{1:{"韋小寶":{"雙兒":"刺客","建寧":{"公主":{"吳三桂":"熊"}},"龍兒":{"教主老婆":"教主"}}}}
      }
print(dic[201][1]["韋小寶"]["建寧"]["公主"]["吳三桂"])# 熊
print(dic[103][1]["蔡徐坤"]["跳"][0])# 鋼管舞
print(dic[102][2]["鄧紫棋"][1]) # 黑風雷

7，set

集合：set
Python 的基礎資料型別之一
定義方式：s = {1,2,3.4,5,6,7,8,9}
空集合：s = set()
天然去重
- 刪的重復的是后面的，先讀取的不洗掉
- 元素要求是不可變的并且還是唯一的,我們就利用它是唯一來做去重
- 會自動排序輸出的集合，從左至右，由小到大
無序,可變的資料型別

frozenset來保存資料

s = frozenset(["趙本六", "劉大腦袋", "謝廣坤", "老四"])
dic = {s:'123'} # 可以正常使使用了
print(dic)

集合的增

集合名.add(“元素”)
集合名.update(“asdaf”)，迭代添加,而且是隨機進添去的

print(set(“xuyu”)) ，只能添加到空集合

s = set()
s.add("alex") # 直接添加
print(s) # {'alex'}
s.update("wusir")  # 迭代添加
print(s) # {'s', 'r', 'alex', 'i', 'u', 'w'}
print(set("xuyu")) # {'y', 'u', 'x'}

集合的刪

集合名.remove(元素)

s = {1,2,3,4,5,6,7,8,9,0}
print(s.remove(3))# 通過元素洗掉
print(s.clear())# 留下的是空集合
print(s.pop())#隨機洗掉，默認應該是洗掉所有元素中最小的

集合名.clear()
集合名.pop()

集合的改

刪了重新添加

集合的查

for回圈

# set是一個可迭代物件. 所以可以進for回圈
for el in s:
 print(el)

s1 = {"劉能", "趙四", "謝廣坤"}
s2 = {"劉科長", "王大拿", "謝廣坤"}
# 交集
# 兩個集合中的共有元素
print(s1 & s2) # {'謝廣坤'}
print(s1.intersection(s2)) # {'謝廣坤'}
# 并集
print(s1 | s2) # {'劉科長', '劉能', '王大拿', '謝廣坤', '趙四'}
print(s1.union(s2)) # {'劉科長', '劉能', '王大拿', '謝廣坤', '趙四'}
# 差集
print(s1 - s2) # {'劉能', '趙四'} 得到第1個中單獨存在的
print(s1.difference(s2)) # {'劉能', '趙四'}
# 反交集
print(s1 ^ s2) # 兩個集合中單獨存在的資料 {'劉科長', '王大拿', '趙四', '劉能'}
print(s1.symmetric_difference(s2)) # {'劉科長', '王大拿', '趙四', '劉能'}
s1 = {"劉能", "趙四"}
s2 = {"劉能", "趙四", "皮長山"}
# 子集
print(s1 < s2) # set1是set2的子集嗎? True
print(s1.issubset(s2))
# 超集（父集）
print(s1 > s2) # set1是set2的超集嗎? False
print(s1.issuperset(s2))

三，基礎資料型別總結

基礎資料型別總結：可變,不可變,有序,無序
- 可變：
  - list
  - dict
  - set
- 不可變：
  - int
  - str
  - tuple
  - bool
- 有序，可索引：
  - str
  - list
  - tuple
- 無序，不可索引：
  - set
  - dict
資料型別轉換

int <——> str

? s = str(int)，沒有條件

? i = int(str)，轉換的字串必須是數字

int <——> bool

? 非0就是True，0是False

? 轉換數字：F = 0，T = 1

str <——> bool

? Fasle = “” ， True = " "

? str = “False” ，str = “True”

list <——> tuble

? list = list(tuple)

? tuple = tuple(list)

list <——> set

? list = list(set)

? set = set(list)

tuple <——> set

? tuple = tuple(set)

? set = set(tuple)

以下非常重要：

list ——> str
```
lst = ["1","2","3"]
print("".join(lst))
```
str ——> list
```
s = "alex wusir 太白"
print(s.split())
```

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/191481.html

標籤：Python

上一篇：《自拍教程10》一些良好的習慣建議

下一篇：Python3 基本語法學習筆記