基本數據類型常用功能：
1.整數，int
    a. n1=123
       n2=456
       print(n1+n2)

       print(n1._add_(n2))

    b.
    獲取可表示的二進制最短位數
        n1=4
        ret=n1.bit_length()
        print(ret)
一：運算符
    in
    "hello" in "aaaaaaaaaaa"
    "li"  in [‘li‘,‘ok‘]

二：基本的數據類型
int
    a.創建方式
    n1=123              #根據int類創建了一個對象
    n2=int（123）       #根本int類。創建一個對象
    特有的功能在：
        int類：
                功能1
                功能2
                功能3
                _init_
    b.int內部優化
        n1=123
        n2=n1

        n1=123
        n2=123
        _+++++++++++++倆份內存
        -5~257
            n1=123
            n2=123
            else:
            n1=123
            n2=123
           ======>對象的內存地址=id(對象或者對象的變量名)

    c.長度限制
    用int，超出了範圍
    int會根據計算機的不同會指定範圍不一樣
    32  -2**31~2**31
    64  -2**63~2**63
    long類型的長度限制：
    跟其他語言不一樣，python的裏面內存有多大，就可以占多少位
    （依據電腦的而產生的界限）

str(string):
s1="alex"
s1=str(‘alex‘)

str()

C.公共功能
    索引：只能去一個元素
    切片：取多個元素
    len:
        len("姓名")
        len("姓名")
    for:
        3.5===>字符來搞的
    編碼：
        namee=“李露”
        for i in name:
            print(i)
            byte_list=byte(i,encoding=‘utf-8‘)
            print(byte_list)
            for b in byte_list:
        1.3.5 for循環的時候，循環的每一個元素是"字符"
        2.字符=》字節
        byte_list=byte("字符串"，encoding=‘utf-8‘)
                #utf-3字節
                #gbk-2字節
        print(bytes_list)#默認每一個字節都是16進制表示
        for b in bytes_list:
            print(b)      #默認每一個字節都是10進制表示
        3.10進制的數字==>2進制
        len
        id
        bin(10進制的數字)

d.bytes和str的轉換
a="小龍"
#將字符串轉換成字節
b1=bytes(a,encoding="utf-8")
print(b1)
b2=bytes(a,encoding="gbk")
print(b2)
#將字節轉換成了字符串

newsa1=str(b1,encoding="utf-8")
print(newa1)
newsa2=str(n2,encoding="gbk")
print(news2)

###############
x=ste()
#創建字符串
#轉化成字符串，字節，編碼


list:可變元素的“集合”
str ->創建字符串，或者將其他的轉換成字符串
list->創建列表，將其他的元素轉換成列表

創建和轉換
    1.創建
        li=[11,22,33,4]
        li=list()
        li=list([11,22,33,4])
    2.轉換
        s1="小龍"
        #for，字符==》可叠代
        l1=list(s1)#for循環，將循環的每一個元素，當做列表的元素
        #["小","龍"]
        print(l1)
        l1=list(s1)#for循環，將循環的每一個元素，當成列表的元素
        # ["李"，"露"]
             print(l1)
             t2=("alex","laonanhai","seven")
             l2=list(t2)
             print(l2)
             dic={‘k1‘:"alex",‘k2‘:"demo"}
             l3=list(dic.items())
             print(l3)


b.列表
     li=list()
     # 追加
    # li.append()
    #清除
    #li.clear()
    #擴展自己，用另外一個可叠代的對象來擴充到自己內部
    # str,list,dict,tuple
    # s="李露"
    # li.extend(s)
    # print(li)
    #反轉，自己內部元素反轉
    # li.reverse()
    #向指定位置插入指定元素
    # li.insert(1,"x")
c.公共功能
    li=["alex","eric","seven"，123]
    索引：li[2]
    切片：li[2:3]
    for
    len
d.列表的嵌套
    li=["alex","eric","seven",123]
    li=["alex",123,{"k1":"v1","k2":{"vv":123,"ii":456}}]
    li[2]--->{"k1":"v1","k2":{"vv":123,"ii":456}}
    li[2][‘k2‘]["vv"]==>(11,22,123)
    li[2][‘k2‘]["vv"]==(11,22,123)
    d={"k1":"v1"}


元組：
a.創建和轉換
    t=(11,22,33)
    t=tuple((11,22,33))
    t=tuple([])#字符串，列表，字典

b.特殊方法
    count
    index
c.嵌套(元素不可修改)
    t=(11,22,33)
    t=(11,22,["alex",{‘k1‘:"v1"}])
    t[2][1]{‘k1‘}

e.元祖的特性，不可修改，元祖的元素不可修改
    元祖的兒子不能變，但是孫子可能會變的。


整理：
一般字符串，執行一個功能，生成一個新內容，原來的內容不變
list,tuple,dict 執行一個功能，自身進行變化。

    字典：
        1.創建
            a={"k1":123}
            a=dict([k1=123,k2=456])

            li=[11,22,33]
            new_dict=dict(enumerate(li))
            print(new_dict)
        2.字典內部功能

前幾天的回顧