一 上节课拾遗

1 运算符 

  in

   字符串 判断  : “hello” in "asdasfhelloasdfsadf"

   列表元素判断:"li" in ['li', 'ok']

   字典key判断:key in dic.keys()

2 基本的数据类型

        类名()  其实就是执行类的 __init__
        
        int()
            __init__(self,args,base=10)
    
int
        a. 创建方式 两种
            n1 = 123      # 根据int类,创建了一个对象
            n2 = int(123) # 根据int类,创建了一个对象 类的实例化就是对象
        b. int内部优化
            1、n1 和 n2 的内存地址相同
                n1 = 123
                n2 = n1
            2、按理说 n1 和 n2 的内存地址不相同
                n1 = 123
                n2 = 123
            但是Python内部做了优化,
                -5 ~ 257 以内的数,按照 2 的方式写时,都是指向同一个内存
                    n1 = 123
                    n2 = 123
                除此以外的数,都是n1 和 n2 的内存地址不相同  python源码可以改取值范围
                    n1 = 123123
                    n2 = 123123
            3、id查看对象的内存地址
                    n1 = 123
                    i1 = id(n1)
                    print(i1)
                或者
                    i1 = id(123)
                    print(i1)
    
        c. int长度限制
                32    -2**31 ~ 2 **31 -1
                64    -2**63 ~ 2**63 - 1
       数字后有L 代表长整型
            python 2.2之后,超过int的最大长度后,会自动转换成long类型,long类型无长度限制
            
            python 3之后,int自己就无长度限制了

        
    str,
        a. 创建方式
            s1 = "alex"
            s1 = str('alex')
            s1 = str('alex') #传参 字节和编码
        b. 特有功能
            # 两端去除空格
            # s1.strip()

            # 以 .. 开头
            # s1.startswith()

            # 找子序列 "12","h"
            # s1.find()

            # 将字符串中的某子序列替换成 指定的值
            # s1.replace()

            # 变大写
            # s1.upper()

            # 是。。。吗?
            # s1.isalpha()
            
        c. 公共功能
            索引:只能取一个元素
            切片:取多个元素
            len:
                len("刘建佐")
                3.5 ==》 字符  (utf-8 中 规定1个汉字3个字节,但是3版本中 1个汉字就是一个字符,不是字节。所以这里len是3)
            for3.5 ==》 字符  (3 版本中 循环汉字字符串不是字节,而是按照字符来进行循环的)
                
            编码、for   bytes方法:转换成字节
          3版本python中 汉字字符串循环不是按照字节循环,而是按照字符循环。
                name = "李露"
                for i in name:
                    print(i) #循环打印每个汉字而不是字节
                    bytes_list = bytes(i, encoding='utf-8')  #将汉字转成字节,编码是utf-8
                    print(bytes_list)
                    for b in bytes_list:
                1、3.5 for循环时候,循环的每一个元素是 “字符”
                2、字符 =》 字节
                    bytes_list = bytes("字符串",encoding='utf-8')
                    
                        # utf-8 -> 3字节 1个汉字
                        # gbk   -》 2字节 1个汉字
                    print(bytes_list) # 默认每一个字节都是16进制表示
                    for b in bytes_list:
                        print(b)      # 默认每一个字节都是10进制表示
                
                3、10进制的数字 ==》 2进制
                    len
                    id
                    bin(10进制的数字)
        d、 bytes和str的转换   将字节转换成字符串 bytes方法
                a = "李露"
                # 将字符串转换成字节
                b1 = bytes(a, encoding='utf-8')
                print(b1)
                b2 = bytes(a, encoding='gbk')
                print(b2)
                # 将字节转换成字符串

                newa1 = str(b1, encoding="utf-8")
                print(newa1)

                newa2 = str(b2, encoding='gbk')
                print(newa2)


                ###########
                x = str()
                # 创建字符串
                # 转换成字符串,字节,编码
                m = bytes()
                # 创建字节
                # 转换成字节,字符串,要编程什么编码类型的字节

python进制转换
hex 可以 十进制转16进制   二进制转16进制    结果都是字符串
>>> hex(0b10)
'0x2'
>>> hex(10)
'0xa'
bin 可以十进制转2进制  16进制转2进制   结果都是字符串
>>> bin(10)
'0b1010'
>>> bin(0x2)
'0b10'
int 可以16进制转换十进制 2进制转换十进制 
>>> int(0xe)         
14                   
>>> int(0b100)       
4                    
 

    list
        可变元素的“集合”
        
        -----------
        str -> 创建字符串,或者将其他的转换成字符串
        ------------------------------------------
        list -> 创建列表,将其他元素转换成列表
        
        a. 创建和转换
            1、创建
                li = [11,22,33,4]
                li = list()
                li = list([11,22,33,4]) 
            2、转换  注:放可迭代的 凡是可以for循环的都可以迭代。  字符串 元组 字典 列表本身 都可以迭代
                s1 = "李露"
                # for,字符 ==> 可迭代
                l1 = list(s1) # for循环,将循环的每一个元素,当做列表的元素
                # ["李", "露"]
                print(l1)
                        
         # 元组 转换成列表
                # t2 = ("alex", "laonanhai", "seven")
                # l2 = list(t2)
                # print(l2)

                # 字典  转换成列表
                # dic = {'k1': "alex", "k2": 'seven'}
                # l3 = list(dic.items())
                # print(l3)
                # 字符串,元组,字典 =》 列表

        b. 列表特有功能
            # 追加
            # 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]
            del
       enumerate
            for
            len
        join
        d. 多层列表 字典取值
            li = ["alex", "eric", 'seven', 123]
            li = [ "alex" , 123, {"k1":"v1", "k2": {"vv": (11,22,123), "ii": 456}}]
            
            li[2] --> {"k1":"v1", "k2": {"vv": 123, "ii": 456}}
            li[2]['k2'] ==> {"vv": 123, "ii": 456}
            li[2]['k2']["vv"] ==> (11,22,123)
            li[2]['k2']["vv"][2]
                
    元组 tuple   转换时候放可迭代的,即可以for循环取的类型。 比如  字符串  列表 字典都可以循环
        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"}])

            
        e. 元组的特性,不可修改,谁不可被修改  #如果元素是列表或者字典可以修改
            元组,儿子不能变
            元组,儿子不能变,孙子,...
            
      整理: 元组 字符串 特性总结
          一般字符串,执行一个功能,生成一个新内容,原来内容不变
          list,tuple,dict,执行一个功能,自身进行变化
上节拾忆 基本数据类型

相关文章:

  • 2021-08-31
  • 2022-02-15
  • 2021-08-25
  • 2022-12-23
  • 2021-07-03
猜你喜欢
  • 2021-06-16
  • 2022-01-02
  • 2022-01-18
  • 2022-12-23
  • 2021-08-30
  • 2021-06-18
相关资源
相似解决方案