基础数据类型总结

一, 字符串str

  • 用' ',"" "" ,''' ''',""" """,引起来的内容是字符串

  • 字符串拼接:"a" + "b" => "ab" ,都是字符串才能相加

  • 字符串 * 数字: "a" * 3 => "aaa"

  1. 用于储存小量的数据

  2. python中用' '," ",''' ''',""" """括起来的就是字符串

  3. 常用操作

    1. 索引: 索引就是下标,从左向右, 从0开始;从右向左,从-1开始

      num = "1234567890"
      print(num[1])  => 2
      print(num[4])  => 5
      print(num[-1]) => 0
      print(num[-2]) => 9
      print(num[21]) # 索引超出范围,报错
      
    2. 切片:使⽤索引来截取部分字符串的内容

      • 语法: str[start: end: step]

      • 规则: 顾头不顾尾, 从start开始截取, 截取到end位置,但不包括end。

        num = "0123456789"
        num[::] == num[:]  # 从头取到尾
        print(num[0:3])  =>  012 # 不包含索引3对应的"3"
        print(num[5:8])   =>  567
        print(num[5:])    =>  56789  # 想取到最后,end可以不写
        print(num[5:20])  =>  56789  # 索引超出范围,不会报错
        print(num[-1:-5:-1]) => 9876 # step步长决定取值的方向,默认为1
        print(num[1:7:2]) =>  135    # step步长决定取值的步子大小,即每step个取一个
        
    3. 常用方法

      • 切记, 字符串是不可变的对象, 所以任何操作对原字符串是不会有任何影响的
      name = "Hello World"
      print(name.upper()) => HELLO WORLD  字母全部转换成大写
      print(name.lower()) => hello world  字母全部转换成小写
      print(name.startswith("H"))  => True  是否以"H"开头
      print(name.endswith("d"))    => True  是否以"d"结尾
      print(name.count("o"))       => 2     统计"o"出现的次数
      print(name.replace("H","A",次数)  => Aello World  # 将H替换成A,默认全部替换,可以输入替换次数
      
      a = "  Alex  "
      print(a.strip()) => Alex  # 去掉两端的某些元素,()内可以指定元素,默认是空白(空格和\n)
      
      b = "1,2,3"
      print(b.split(",")) => ["1","2","3"]  # 分割,可以指定用于分割的元素,分割后损失这个元素,默认以空格分隔,返回一个列表。
      
      • is 判断系列
      name.isdigit()   # 判断是不是阿拉伯数字,有漏洞
      name.isdecimal() # 判断是不是十进制,可以用于判断数字
      name.isalpha()   # 判断是不是中文和字母
      name.isalnum()   # 判断是不是中文,字母和数字
      

二, 整型int

  1. 用于计算和比较,在python3中所有的整数都是int类型

  2. 二进制和十进制的转换

    • 十进制转换成二进制:

      正整数转换成二进制:除二取余,倒序排列,高位补零

      14 % 2 = 0
      7  % 2 = 1
      3  % 2 = 1
      1  % 2 = 1
      0
      14转换为二进制为:0000 1110
      

      负整数先转换成对应的正整数,转换成二进制,对二进制取反,再对结果加一

    • 二进制转换成十进制:

      先将二进制补齐位数,如果首位是0代表是正整数,首位是1代表是负整数

      • 正整数:补齐位数后,将二进制中的位数分别将下边对应的值相乘,然后相加得到十进制

        1010  
        # 先补齐位数  =>  0000 1010     128  64   32  16   8   4   2   1 常用的8位
        2**3 *1 + 2**2 * 0 + 2**1 * 1 + 2**0 * 0  =  10
        
      • 负整数,先对二进制取反,再进行换算

  3. bit_length()

    求十进制数转换成二进制时所占用的长度

三, 布尔值bool

  • True(真) => 1,False(假) => 0
  • True 真 非0数字 非空字符串
  • False 假 0 空字符串
  • 类型转换:想要转换成什么类型,就用这个类型把需要转换的内容括起来
a = "hahahahaha"
b = "123456"
c = 123456
a1 = bool(a)  => True
b1 = int(b)   => 123456
c1 = str(c)   => "123456"

四, 列表list

  1. 可以有序的存储大量数据,用以[ ]括起来,每个元素⽤' , '隔开⽽且可以存放各种数据类型。

  2. 列表时可变的,即可以在本身上进行修改。

  3. 列表的索引和切片

    • 列表和字符串一样是有索引的,也是可迭代的

      li = [1,2,3,"123",True]
      print(li)
      print(li[-2],type(li[-2]))  # 索引查找
      print(li[1:4])              # 支持切片   切片所得是列表
      print(li[-2:1:-1])          # 支持步长
      
  4. 列表的增删改查

    • 注意, list和str是不⼀样的. lst可以发⽣改变. 所以直接就在原来的对象上进⾏了操作

    • li.append("4")     # 追加,在末尾添加一个元素
      li.extend([5,6])   # 扩展,迭代添加."10" => "1","2"
      li.insert(0,"A")   # 按索引位置插入一个元素,效率特别低
      
      li2 = [4,5,6]
      li3 = li + li2     # 列表合并
      
    • lst = ["麻花藤", "王剑林", "李嘉诚", "王富贵"]
      deleted = lst.pop() # 弹出,可以指定索引位置,默认弹出最后一个元素,有返回值,返回的是弹出的元素
      el = lst.pop(2) # 删除2号元素
      lst.remove("麻花藤") # 删除指定元素,必须知道元素的内容
      lst.remove("哈哈") # 删除不存在的元素会报错
      lst.clear() # 清空list,清除列表内全部的信息,得到一个空列表
      del lst[2]   # 删除特定索引位置的元素
      del lst[1:3] # 删除特定索引范围内的元素,也可以改变步长
      
    • li = [1,2,3,"123",True]
      li[0] = "1"         # 指定位置修改
      li[1:3] = [9,8,7]   # 迭代修改,支持切片修改
                          # 使用步长时注意取几个必须放几个,步长为1时则不需要注意个数。
      
    • li = [1,2,3,"123",True]
      print(li[1])   # 指定索引位置查询
      
      for each in li:
      	print(each)
      # 列表是⼀个可迭代对象, 所以可以进⾏for循环
      
      
  5. 列表的嵌套

    采用降维操作,一层一层的看

li = [1,2,3,"123",[9,8,7]]
li[-1][0] => 9


## 五, 元组tuple

1.  俗称不可变的列表。⼜被成为只读列表,元组也是python的基本数据类型之⼀,⽤⼩括号括起来,⾥⾯可以放任何数据类型的数据,查询可以,循环也可以,切片也可以,但就是不能改。

tu = (1,2,3,"123",[1,2,3])
for each in tu:
print(each) # 元组也是可以迭代的,可以用for循环遍历

tu = (1,) # 注意,如果元组中只有一个元素,一定要在后面添加一个逗号,否则就不是元组
tu = ()
tu = tuple() # 创建空元组

  1. 列表list

    li = [1,2,3,4]
    l2 = list("1234")   # 定义的一种方式
    print(li.count(1))  # 统计1出现的次数
    print(li.index(1))  # 查找1的第一个索引,查找不到就报错
    li.reverse()         # 原地反转
    li.sort(reverse=True) # 排序,默认升序,加True就降序
    
  2. 元组tuple

    tu = (1,2,3,4,5)
    tu1 = tuple("12345") # 定义的一种方式
    tu.count(1)  # 统计
    tu.index(1)  # 通过元素找索引,找不到就报错
    
  3. 字典dict

    dic = {1:"a",2:"b"}
    dic1 = dict(k=1,k1=2)  # 定义的一种方式
    dic.popitem()   # 随机删除,返回删除的值,3.6版本后默认删除最后一个键值对
    dic2 = dict.fromkeys("123",1)  # 批量创建字典,迭代key,value相同,指向同一内存地址
    
    
  4. 结合set

    s = set("1234")  # 定义的一种方式
    
  5. 类型转换

    str => int :字符串中必须全部都是十进制的数字
    int => str :直接转换
    str => list :
    s = "1234"
    lst = list(s) => ["1","2","3","4"]
    或用split()切割
    list => str :使用join进行拼接,元素中不能有int
    list => tuple :直接转换
    set => list :直接转换
    总结:
    字符串 -- 数字  :字符串中必须都是十进制的数字
    数字 -- 字符串  :直接转换
    列表 -- 字符串  :join()拼接--可迭代的对象中不能出现数字
    字符串 -- 列表  :split()分割
    除字典外,容器数据类型都能直接相互转换
    
  6. 总结

    有序: str,int,bool,list,tuple
    无序: dict,set
    可变: list,dict,set
    不可变: str,int,bool,tuple
    
    访问方式:
    直接访问: int,bool,set
    顺序访问:str,list,tuple
    键访问: dict
    
  7. 坑人的删除

    li = [1,2,3,4,5]
    # 面试题:要求用一个for循环对删除上述列表索引为奇数位置的元素
    for el in range(len(li)-1,-1,-1):
        if el % 2 == 1:
            li.pop(el)
    print(li)
    # 尽量不要在for循环遍历列表的同时修改列表本身的大小
    
    # for循环迭代字典过程中改变字典的大小会报错
    
posted @   怀心抱素  阅读(349)  评论(0编辑  收藏  举报
点击右上角即可分享
微信分享提示