摘要：基本數據類型數字類型只能存取一個值數字是不可變類型，根據來看，不可變類型是可數字主要是用來計算的，使用方法不是很多，記住如下一種整數類型當十進制用二進制來表示的時候，最少使用的位數浮點型身高體質參數體重復數布爾值布爾值只有兩種一種是一種是真

只能存取一個值

數字是不可變類型，根據id來看，不可變類型是可hash

數字主要是用來計算的，使用方法不是很多，記住如下一種

1.整數類型(int)當十進制用二進制來表示的時候，最少使用的位數

age = 18
print(age.bit_length())

2.浮點型(float)身高,體質參數,體重

salary = 3.1   #salary = salary(3.1)
print(salary,type(salary))

3.復數(complex)

x = 1 + 2j
print(x.real)
print(x.imag)
print(type(x))

布爾值,只有兩種一種是True,一種是False

真為：True
假為：False
在數字中：只有0為False，其余為True
在字符串中：只有空為False，其余為True

字符串只有一個值

字符串是有序的

不可變類型，可被hash

1.索引
字符串是有序的，可以按照索引取值

name = "tianjianyu"
print(name[0])   #取第一個值
print(name[-1])  #取最后一個值

2.切片就是通過[索引：索引：步長]取字符串的一段，行成一段新的字符串，原則是顧頭不顧尾

name = "tianjianyu"
print(name[0:4])     #比如取tian字符串,t為0，n為3，但是切片顧頭不顧尾，需要3的位置在加1位，才能取到tian
print(name[0:4:1])   #這個1為步長，默認為1，也可以自己指定
print(name[:])       #初始位置不寫,最后位置也不寫，取的是該字符串的全部
print(name[::-1])    #初始位置不寫,最后位置也不寫,但是步長為-1，相當于將整個字符串翻轉

3.captalize,swapcase,title

str_1 = "tianjianyu"
print(str_1.capitalize()) #首字母大寫
str_2 = "Tian Jian Yu"
print(str_2.swapcase())   #大小寫翻轉
str_3 = "tian jian yu"
print(str_3.title())   #每個字母的首字母大寫
str_4 = "tianjianyu"
print(str_4.upper())  #將字符串的所有字母轉換為大寫
str_5 = "TIANJIANYU"
print(str_5.lower())   #將字符串所有字母轉換為小寫

4."center"用于填充，比如需要長度為20,name會居中，總長度為20,用空格填充

name = "tian"
print(name.center(20))

5.expandtabs

# name="egon	hello"
# print(name.expandtabs(10))
"""
S.expandtabs(tabsize=8) -> str

        Return a copy of S where all tab characters are expanded using spaces.
        If tabsize is not given, a tab size of 8 characters is assumed.
        1.expandtabs后邊的參數為幾就把幾個分在一起；
        比如為2，那么就兩個一組，前邊如果有一個了，就在補充一個；
        反之，如果兩個一組前邊一個沒有，那么就補充兩個空格
"""

6.find,index

name = "hello world"
print(name.find("o",0,4))  #顧頭不顧尾，找到則返回索引位置，找不到則返回-1
print(name.index("o",0,4)) #和find一樣，但是找不到會報錯substring not found

7.count用于統計某個元素的個數

name = "hello"
print(name.count("l"))

8.split將一個字符串以什么切割，行成一個新的列表

name = "tian jian yu"
print(name.split())

9.join的用法，用于字符串的拼接,將一個列表拼接成一個字符串，只有在列表內的所有元素都是字符串才可以拼接

name = ["tian","jian","yu"]
print(" ".join(name))

9.format格式化的方法

print("my name is {} age is {}".format("tian",18))
print("my name is {name} age is {age}".format(name="tian",age=18))

10.replace將字符串中的元素進行替換，如果不重新賦值，字符串是不可變類型

msg = "hello"
print(msg.replace("l","d",1))

11.isalnum,isdigit,isalpha判斷字符串的組成

name="tianjianyu123"
print(name.isalnum()) #字符串由字母或數字組成
print(name.isalpha()) #字符串只由字母組成
print(name.isdigit()) #字符串只由數字組成

元組適用于不變的數據

元組是有序的

元組是不可變類型(但是元組可以對嵌套的列表內的元素修改)

1.定義：

age = (1,2,3,4)
print(age,type(age))

2.索引取值

age = (1,2,3,4)
print(age[1])

3.切片

age = (1,2,3,4)
print(age[0:3])

4.根據元素找索引位置

age = (1,2,3,4)
print(age.index(1))

5.count統計某個元素出現的次數

age = (1,2,3,4)
print(age.index(1))

存一個值或者多個值，值為任意類型

有序，可以按照索引取值

可變類型

1.定義方式，"[]"內可以有多個任意類型的值，用","分割

name = ["tian","jian","yu",1,2,3]  #本質name = list([...])
print(list("hello"))    #傳個字符串的方式

2.索引取值

name = ["tian","jian","yu",1,2,1]
print(name[1])

3.切片顧頭不顧尾

name = ["tian","jian","yu",1,2,1]
print(name[0::1])      #取全部列表，步長為1
print(name[-1::-1])    #反向去列表全部，類似revers功能

4.增：insert,append,extend

name = ["tian","jian","yu"]
name.insert(0,"qudi")    #insert指定索引位置添加，如果指定的索引不存在,則在最后添加
name.append("tianjianyu") #增加到最后
name.extend("abc")        #迭代的去增加
print(name)  #最后打印結果為：["qudi", "tian", "jian", "yu", "tianjianyu", "a", "b", "c"]

5.刪：pop,del,remove,clear

name = ["tian","jian","yu"]
name.pop(0)   #按照索引去刪，返回值為刪掉的元素
name.remove("tian")   #按照元素去刪除。返回值為None，拿不到結果
name.clear()     #清空列表
del name[0:1]   #按照位置去刪除，也可切片刪除沒有返回值

6.改

name = ["tian","jian","yu"]
name[0] = "qudi"       #將索引0位置替換為qudi
name[1:2] = ["a","b"]   #按照切片去替換
print(name)             #["qudi", "a", "b", "yu"]

7.查index,切片，for循環

name = ["tian","jian","yu"]
print(name.index("tian"))    #按照元素查找返回索引位置

name = ["tian","jian","yu"]
for i in name:              #使用for循環查
    print(i)

8.count統計某個元素出現的次數

name = ["tian","jian","yu","tian"]
print(name.count("tian"))

9.sort,reverse

a = [5,6,8,9,1,2]
a.sort()
print(a)   #[1, 2, 5, 6, 8, 9]正序

a = [5,6,8,9,1,2]
a.sort(reverse=True)
print(a)   #[9, 8, 6, 5, 2, 1]倒序

a = [5,6,8,9,1,2]
a.reverse()
print(a)   #[2, 1, 9, 8, 6, 5]整個列表翻轉  

按照key：value，存取速度快，可以是任意類型,key必須是不可變類型

3.6版本以前是無序的，3.6以后是有序的，有序不是可以按照索引取值

可變

1.增

dic = {"name":"tianjianyu","age":24}
dic["hobbies"] = "gril"    #增加一對key，val如果key有則將val的值賦值成新的，沒有則添加一對新的key，val
dic["name"] = "qudi"
print(dic)

dic = {"name":"tianjianyu","age":24}
dic.setdefault("name")     #在字典中添加鍵值對，如果只有鍵那對應的值是none,但是如果原字典中存在設置的鍵值對，則他不會更改或者覆蓋
dic.setdefault("hobbies")
print(dic)

2.刪：pop,popitem,clear,del

name_dict  = {"name":"qudi","age":18}
print(name_dict.pop("name"))   #pop傳key值可以返回值
print(name_dict.popitem())     #刪除一對鍵值對，返回值為元祖
print(name_dict)
print(name_dict.clear())  # 清空字典，沒有返回值
del name_dict   #刪除整個字典

3.改

dic = {"name":"tianjianyu","age":24}
dic["name"] = "qudi"   #取到key值之后重新賦予新值

dic1 = {"name":"tianjianyu","age":24}
dic2 = {"name":"qudi","age":25,"hobbies":"boy"}
dic1.update(dic2)   #將dic2所有的鍵值對覆蓋添加（相同的覆蓋，沒有的添加）到dic1中
print(dic1)         #{"name": "qudi", "age": 25, "hobbies": "boy"}

4.查

dic = {"name":"tianjianyu","age":24}
dic1 = dic["hobbies"]     #如果沒有該key值會報錯,KeyError: "hobbies"
print(dic1)

dic = {"name":"tianjianyu","age":24}
dic1 = dic.get("name")  #沒有該key，不會報錯，可以返回自定義的返回值，有則返回val值
print(dic1)

5.keys,values,items

dic = {"name":"tianjianyu","age":24}
print(dic.keys())                      #以類似元組的形式返回所有的key,dict_keys(["name", "age"])
print(dic.values())                    #以類似元組的形式返回所有的val,dict_values(["tianjianyu", 24])
print(dic.items())                     #以類似元組的形式返回一對key,val,dict_items([("name", "tianjianyu"), ("age", 24)])

6.字典的循環

dic = {"name":"tianjianyu","age":24}
for key in dic.keys():          #dic后邊不寫,默認是key
    print(key)
for val in dic.values():
    print(val)
for key,val in dic.items():    #
    print(key,val)

7.字典fromkeys用于創建一個新字典，以序列seq中元素做字典的鍵，value為字典所有鍵對應的初始值。

seq = ("name", "age", "sex")
dict = dict.fromkeys(seq)
print(dict)

作用：關系運算，去重{}號內可以用逗號分隔，每個元素必須是不可變類型（不可hash）

集合內的元素不能重復

無序，不能按照索引取值

1.交集&兩個集合相同的數字，不同的數字去掉

set_1 = {1,2,3,4}
set_2 = {1,3,4,5}
print(set_1&set_2)

2.合集|所有的數字，相同的數字去掉

set_1 = {1,2,3,4}
set_2 = {1,3,4,5}
print(set_1 | set_2)

3.對稱差集，沒有同時在兩個列表中的數字

set_1 = {1,2,3,4}
set_2 = {1,3,4,5}
print(set_1 ^ set_2)

4.差集

set_1 = {1,2,3,4}
set_2 = {1,3,4,5}
print(set_1 - set_2)    #只存在set_1中的值
print(set_2 - set_1)    #只存在set_2中的值

5.父集

set_1 = {1,2,3,4}
set_2 = {1,2,3}
print(set_1 >= set_2)    #True,判斷set_1是否包含set_2
print(set_2 >= set_1)    #False,判斷set_2是否包含set_1

6.子集

set_1 = {1,2,3,4}
set_2 = {1,3,4}
print(set_1 <= set_2)   #False
print(set_2 <= set_1)   #True

注：
1.判斷父集用>=,返回值為True，證明為父集
2.判斷子集用<=，返回值為True,證明為子集
練習：
1.

l1 = [11, 22, 33, 44, 55]
將索引為奇數對應的元素刪除。
del l1[1::2]  # 根據切片步長找出索引為奇數
print(l1)
for i in range(len(l1)):  # 循環列表時，不要改變列表的大小，否則會影響結果
    if i % 2 == 1:
        l1.pop(i)
print(l1)
for i in range(len(l1) - 1, -1, -1):  # 按照索引倒敘的方式刪除，不會影響前邊的列表順序
    if i % 2 == 1:
        del l1[i]
print(l1)

2.

dic = {"k1": "v1", "k2": "v2", "k3":"v3", "name":"alex"}
#刪除字典中所有key中帶有"k"的鍵值對
l1 = []
for i in dic:   
    if "k" in i:   
        l1.append(i)   #循環一個字典時，不要改變字典的大小，否則會影響結果
for i in l1:
    del dic[i]
print(dic)

1.淺copy,外層是獨立的，里邊的是同一塊內存空間

#1.
# list1 = [1,2,3]
# list2 = list1.copy()
# list1.append(4)
# print(list1,id(list1))
# print(list2,id(list2))
#2.切片的淺copy方法
# list1 = [1,2,3,[1,2,3]]
# list2 = list1[:]
# list1[-1].append(4)
# list1.append(4)
# print(list1,id(list1))
# print(list2,id(list2))

2.深copy

import copy
# s1 = [1, 2, 3,[11,22]]
# s2 = copy.deepcopy(s1)
# s1.append(666)
# print(s1, s2)

# s1 = [1, 2, 3,[11,22]]
# s2 = copy.deepcopy(s1)
# s1[-1].append(666)
# print(s1, s2)
# 深copy 無論多少層，都是互相獨立的。