数据类型及内置方法1

零、

• 可变类型：值改变的情况下，id不变

• 不可变类型：只改变的情况下，id变化

• 有序：但凡有索引的数据都是有序的

一、整型

1. 用途

   存qq号，手机号，不带字母的身份证号码

2. 定义方式

   age = 18

3. 可变or不可变

   不可变

4. 进制转换

   • 其他进制转十进制

     # 二进制转十进制
     10 —— 1 * (2 ** 1) + 0 * (2 ** 0)
     
     # 八进制转十进制
     
     235 —— 2 * (8 ** 2) + 3 * (8 ** 1) + 5 * (8 ** 0)
     
     # 十六进制转十进制
     
     217 —— 2 * (16 ** 2) + 1 * (16 ** 1) + 5 * (8 ** 0)

   • int 可以传第二个参数，表示第一个参数是什么进制，然后转成十进制

     - print(int('1100', 2))
     - print(int('14', 8))
     - print(int('c', 16))

   • 十进制转其他进制

     - 十进制转二进制
       print(bin(12))   # 0b1100
     - 十进制转八进制
       print(oct(12))   # 0o14
     - 十进制转十六进制
       print(hex(12))   # 0xc

   二、字符串

   1. 描述

   2. 定义方式

      ‘ ’ “ ” ‘’‘ ’‘’

   3. 有序 or 无序

      有序

   4. 可变 or 不可变

      不可变

   5. 操作和内置方法

      • 按索引取值

        s = 'hello world'
        print(s[0])    # h
        print(s[-1])    # d

      • 切片（顾头不顾尾）

        s = 'hello world'
        print(s[0:5])   # hello
        print(s[0:10:2])    # hlowr
        print(s[5:0:-2])    # le
        print(s[-1:-4:-1])    # dlr

      • len（统计字符个数）

        s1 = '  '
        print(len(s1))    # 2

      • in, not in（判断一个字符串是否存在于一个大的字符串中）

        print('a' in 'abcd')    # True

      • strip（去掉字符串左右两边的字符）

        strip()    # 默认去除字符串首位的空格
        
        name1 = '    byx '
        print(name1.strip())    # byx
        
        name2 = '$by$x$'    
        print(name2.strip('$'))    # by$x    中间的符号不会去除
        print(name2.lstrip('$'))    # by$x$
        print(name2.rstrip('$'))    # $by$x

      • split（将字符串分割成列表）

        data = 'byx|18|male'
        print(data.split('|'))    # ['byx', '18', 'male']    切分成列表
        print(data.rsplit('|', 1))    # ['byx|18', 'male']    从右边切一个'|'

      • for循环

        for i in 'byx':
            print(i, end=' ')    # b y x 

      • lower, upper（大写、小写转换）

        s = 'ByX'
        print(s.lower())    # byx
        print(s.upper())    # BYX
        print(s)    # ByX    s 本身没变

      • startswith, endswith（判断首位）

        s = 'byx'
        print(s.startswith('b'))    # True
        print(s.endswith('x'))    # True

      • join（拼接）

        user_list = ['byx', '18', 'male']
        res = '|'.join(user_list)
        print(res)    # byx|18|male

      • replace（替换）

        str = 'Rome was not built in one day'
        res = str.replace('day', 'month')
        print(res)    # Rome was not built in one month
        print(str)    # Rome was not built in one day    原字符串没变

      • isdigit（ 判断是否输入的数字）

        age = input('请输入年龄')
        if age.isdigit():    
            age = int(age)
        else:
            print('请输入数字')

      • find，index（寻找位置）

        s = 'Rome was not built in one day'
        print(s.find('was'))    # 5    返回所在位置
        print(s.find('xxx'))    # -1    找不到时，返回 -1
        print(s.find('was', 0, 5))    # -1    通过索引限制查找范围，顾头不顾尾
        print(s.find('was', 0, 5))    # 5    只有找到整个‘was’时，才不返回-1，并返回5
        
        print(s.index('was', 0, 5))    # 报错    找不到值报错
        print(s.index('was', 0, 8))    # 5    只有找到整个‘was’时，才不报错，并返回5

      • count（统计出现次数）

        s = 'Rome was not built in one day'
        print(s.count('o'))    # 3

      • center, ljust, rjust, zfill（居中填充，左填充，右填充）

        s = 'byx'
        print(s.center(7, '*'))    # **byx**    居中填充，一共7位字符
        print(s.ljust(7, '*'))    # byx****    左移后填充，一共7位字符
        print(s.rjust(7, '*'))    # ****byx    右移后填充，一共7位字符
        print(s.zfill(7))    # 0000byx    左边用0填充，一共7位字符

      • expandtabs（改变table键空格的个数）

        s = 'b\tyx'
        print(s)    # b yx
        print(s.expandtabs(10))    # b         yx    # table键变为10个空格

      • captalize, swapcase, title

        s = 'RoMe waS nOt BuILT in ONe daY'
        print(s.capitalize())    # Rome was not built in one day    字符串首字母大写
        print(s.swapcase())    # rOmE WAs NoT bUilt IN onE DAy    大小写转换
        print(s.title())    # Rome Was Not Built In One Day    所有单词首字母大写

   三、列表

   1. 定义：[ ]内存放多个任意元素，以逗号隔开

      l = list('abc')
      l1 = list({'name': 'byx', 'age': 18})    
      print(l)    # ['a', 'b', 'c']
      print(l1)    # ['name', 'age']
      # 内部是for循环

   2. 可变 or 不可变

      可变类型

   3. 有序 or 无序

      有序

   4. 操作和内置方法

      • 按索引取值（正向存取+反向存取）

        l = [1, 2, 3, 4]
        print(l[2])    # 3
        
        l[0] = 5    
        print(l)    # [5, 2, 3, 4]    可以通过索引修改元素

      • 切片（顾头不顾尾）

        l = [1, 2, 3, 4]
        print(l[0:4:1])      # [1, 2, 3, 4]
        print(l[0::])    # [1, 2, 3, 4]    默认取到最后，默认步长为1
        print(l[5::-1])    # [4, 3, 2, 1] 

      • len（长度）

        l = [1, 2, 3, 4]
        print(len(l))    # 4

      • in 和 not in（成员运算）

        l = [1, 2, 3, 4]
        print(5 in l)    # False

      • append, insert, extend（添加元素）

        l = [1, 2, 3, 4]
        l.append(5)
        print(l)    # [1, 2, 3, 4, 5]    尾部添加一个元素
        
        l1 = [1, 2, 3, 4]
        l1.insert(2, 5)
        print(l1)    # [1, 2, 5, 3, 4]    通过索引在任意位置添加一个元素
        
        l1 = [1, 2, 3, 4]
        l2 = [5, 6]
        l1.extend(l2)
        print(l1)    # [1, 2, 3, 4, 5, 6]    列表拼接
        
        l3 = [1, 2, 3, 4]
        l3.extend([5,])
        print(l3)    # [1, 2, 3, 4, 5]    内部是for循环，参数要传可迭代对象

      • del, pop, remove（删除）

        l = [1, 2, 3, 4]
        del l[2]    # del 按照索引删除，适用于所有的删除操作 无返回值
        print(l)    # [1, 2, 4]
        del l    # 删除列表
        
        l = [1, 2, 3, 4, 5]
        l.pop()
        print(l)    # [1, 2, 3, 4]    尾部弹出一个参数
        res = l.pop()
        print(res)    # 4    弹出的元素就是返回值
        print(l)    # [1，2, 3]
        res1 = l.pop(1)
        print(res1)    # 2    可以按照索引指定弹出元素
        
        l = [1, 2, 3, 4]
        l.remove(3)
        print(l)    # [1, 2, 4] 指定删除元素，无返回值

      • count（计数）

        l = ['a', 'b', 1, 3, 3]
        print(l.count(3))    # 2
        print(l.count('c'))    # 0

      • clear（清空）

        l = [1, 2, 3, 4]
        res = l.clear()
        print(l)    # []
        print(res)    # None    列表被清空

      • sort, reverse（排序和反转）

        l = [2, 1, 5, 4, 3]
        l.sort()
        print(l)    # [1, 2, 3, 4, 5]
        
        l = [2, 1, 5, 4, 3]
        l.sort(reverse=True)
        print(l)     #[5, 4, 3, 2, 1]

   5. 队列和堆栈

      • 队列（先进先出）

        l1 = []
        # 先进
        l1.append('a')
        l1.append('b')
        l1.append('c')
        # 先出
        print(l1.pop(0))    # a
        print(l1.pop(0))    # b
        print(l1.pop(0))    # c

      • 堆栈（先进后出）

        l1 = []
        # 先进
        l1.append('a')
        l1.append('b')
        l1.append('c')
        # 先出
        print(l1.pop())    # c
        print(l1.pop())    # b
        print(l1.pop())    # a

转载于:https://www.cnblogs.com/binyuanxiang/p/11514660.html