基本数据类型常用功能：
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.字典内部功能

前几天的回顾