Python基本数据类型

一时失言乱红尘 2022-10-30 13:22 408阅读 0赞

在了解基本数据类型的时候，我们需要了解基本数据类型有哪些？数字int、布尔值bool、字符串str、列表list、元组tuple、字典dict等，其中包括他们的基本用法和其常用的方法，这里会一一列举出来，以便参考。然后我们还需要了解一些运算符，因为这些基本数据类型常常会用于一些运算等等。

一、运算符

运算通常可以根据最终获得的值不同，可以分两类，即结果为具体的值，结果为bool值，那么哪些结果为具体的值–>算数运算、赋值运算，哪些结果又为bool值？—>比较运算、逻辑运算和成员运算。

如果对软件测试有兴趣，想了解更多的测试知识，解决测试问题,以及入门指导，帮你解决测试中遇到的困惑，我们这里有技术高手。如果你正在找工作或者刚刚学校出来，又或者已经工作但是经常觉得难点很多，觉得自己测试方面学的不够精想要继续学习的，想转行怕学不会的， 都可以加入我们在这里插入图片描述
，群内可领取最新软件测试大厂面试资料和Python自动化、接口、框架搭建学习资料！

1、算术运算

在这里插入图片描述
2、赋值运算
　　在这里插入图片描述
3、比较运算
在这里插入图片描述
4、逻辑运算
在这里插入图片描述
5、成员运算
在这里插入图片描述

二、基本数据类型

1、数字 —> int类
　　 当然对于数字，Python的数字类型有int整型、long长整型、float浮点数、complex复数、以及布尔值（0和1），这里只针对int整型进行介绍学习。

在Python2中，整数的大小是有限制的，即当数字超过一定的范围不再是int类型，而是long长整型，而在Python3中，无论整数的大小长度为多少，统称为整型int。

其主要方法有以下两种：

int —>将字符串数据类型转为int类型, 注：字符串内的内容必须是数字

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  4. s = '123'
  5. i = int( s )
  6. print( i)

bit_length() —>将数字转换为二进制，并且返回最少位二进制的位数

  1. #!/user/bin/env python
  2. #-*- coding:utf-8 -*-
  4. i =123
  5. print( i.bit_length() )
  7. #输出结果为：
  8. >>>5

2、布尔值 —>bool类
　　　 对于布尔值，只有两种结果即True和False，其分别对应与二进制中的0和1。而对于真即True的值太多了，我们只需要了解假即Flase的值有哪些—》None、空（即 [ ]/( ) /“ “/{ }）、0；

  1. #以下结果为假，即None、‘’、[]、()、{ }以及 0
  2. >>> bool(None)
  3. False
  4. >>> bool('')
  5. False
  6. >>> bool([])
  7. False
  8. >>> bool(0)
  9. False
  10. >>> bool(())
  11. False
  12. >>> bool({ })
  13. False

3、字符串 —>str类
　　　 关于字符串是Python中最常用的数据类型，其用途也很多，我们可以使用单引号 ‘’或者双引号“”来创建字符串。

字符串是不可修改的。所有关于字符我们可以从 索引、切片、长度、遍历、删除、分割、清除空白、大小写转换、判断以什么开头等方面对字符串进行介绍。

创建字符串

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  4. #字符串的形式：使用‘’或者“”来创建字符串
  5. name ='little_five'
  6. print(name)

切片

  1. #获取切片，复数代表倒数第几个，从0开始
  2. >>> name ="little-five"
  3. >>> name[1]
  4. 'i'
  5. >>> name[0:-2] #从第一个到倒数第二个，不包含倒数第二个
  6. 'little-fi'

索引–> index()、find()

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. # 修正版
  4. name = "little_five"
  5. #index-->获取索引，语法->str.index(str, beg=0 end=len(string))，第二个参数指定起始索引beg，第三个参数结束索引end，指在起始索引到结束索引之前获取子串的索引
  6. print(name.index("l",2,8)) #在索引区间2-8之前查找‘l’,找到是第二个‘l’,其索引为4
  8. #find -->其作用与index相似
  9. print(name.find("l",2))  #结果也为 4

index()与find()的不同之处在于：若索引的该字符或者序列不在字符串内，对于index–》ValueError: substring not found，而对于find —>返回 -1。

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  4. name = "little_five"
  6. print(name.index("q",2))
  7. #index--》输出为：
  8. >>>Traceback (most recent call last):
  9.   File "C:/Users/28352/PycharmProjects/learning/Day13/test.py", line 5, in <module>
  10.     print(name.index("q",2))
  11. ValueError: substring not found
  13. print(name.find("q",2))
  14. #find--》输出为：
  15. >>> -1

长度 —>len()

  1. name = "little_five"
  2. #获取字符串的长度
  3. print(len(name))
  5. #输出为：
  6. >>> 11

注：len()方法–>同样可以用于其他数据类型，例如查看列表、元组以及字典中元素的多少。

删除 —> del

  1. #删除字符串，也是删除变量
  2. >>> name ="little-five"
  3. >>> del name
  4. >>> name
  5. Traceback (most recent call last):
  6.   File "<stdin>", line 1, in <module>
  7. NameError: name 'name' is not defined

判断字符串内容 —> isalnum()、isalpha()、isdigit()

  1. #判断是否全为数字
  2. >>> a ="123"
  3. >>> a.isdigit()
  4. True
  5. >>> b ="a123"
  6. >>> b.isdigit()
  7. False
  9. #判断是否全为字母
  10. >>> d ="alx--e"
  11. >>> d.isalpha()
  12. False
  13. >>> c ="alex"
  14. >>> c.isalpha()
  15. True
  17. #判断是否全为数字或者字母
  18. >>> e ="abc123"
  19. >>> e.isalnum()
  20. True

大小写转换 —> capitalize()、lower()、upper()、title()、casefold()

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  4. #大小写的互相转换
  5. >>> name ="little_five"
  6. #首字母大写-->capitalize
  7. >>> name.capitalize()
  8. 'Little_five'
  10. #转为标题-->title
  11. >>> info ="my name is little_five"
  12. >>> info.title()
  13. 'My Name Is Little_Five'
  15. #全部转为小写-->lower
  16. >>> name ="LITTLE_FIVE"
  17. >>> name.lower()
  18. 'little_five'
  20. #全部转为大写-->upper
  21. >>> name = "little_five"
  22. >>> name.upper()
  23. 'LITTLE_FIVE'
  25. #大小写转换-->swapcase
  26. >>> name ="lIttle_fIve"
  27. >>> name.swapcase()
  28. 'LiTTLE_FiVE'

判断以什么开头结尾 —> startswith()、endswith()

  1. #判断以什么开头、结尾
  2. >>> name ="little-five"
  4. #判断以什么结尾
  5. >>> name.endswith("e")
  6. True
  8. #判断以什么开头
  9. >>> name.startswith("li")
  10. True

扩展–>expandtabs()

  1. #expandtabs -->返回字符串中的 tab 符号('\t')转为空格后生成的新字符串。通常可用于表格格式的输出
  3. info ="name\tage\temail\nlittlefive\t22\t994263539@qq.com\njames\t33\t66622334@qq.com"
  4. print(info.expandtabs(10))
  6. #输出为：
  7. name      age       email
  8. little-five         22        994263539@qq.com
  9. james     33        66622334@qq.com

格式化输出–>format()、format_map()

  1. #格式化输出-->format、format_map
  3. #forma方法
  4. #方式一
  5. >>> info ="my name is {name},I'am {age} years old."
  6. >>> info.format(name="little-five",age=22)
  7. "my name is little-five,I'am 22 years old."
  9. #方式二
  10. >>> info ="my name is {0},I'am {1} years old."
  11. >>> info.format("little-five",22)
  12. "my name is little-five,I'am 22 years old."
  14. #方式三
  15. >>> info ="my name is {name},I'am {age} years old."
  16. >>> info.format(**{ "name":"little-five","age":22})
  17. "my name is little-five,I'am 22 years old."
  19. #format_map方法
  20. >>> info ="my name is {name},I'am {age} years old."
  21. >>> info.format_map({ "name":"little-five","age":22})
  22. "my name is little-five,I'am 22 years old."

jion方法

  1. #join--> join(): 连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
  3. #字符串
  4. >>> name ="littefive"
  5. >>> "-".join(name)
  6. 'l-i-t-t-e-f-i-v-e'
  8. #列表
  9. >>> info = ["xiaowu","say","hello","world"]
  10. >>> "--".join(info)
  11. 'xiaowu--say--hello--world'

分割 —> split()、partition()

  1. #分割，有两个方法-partition、split
  3. #partition -->只能将字符串分为三个部分，生成列表
  4. >>> name ="little-five"
  5. >>> name.partition("-")
  6. ('little', '-', 'five')
  8. #split-->分割字符串，并且可以指定分割几次，并且返回列表
  9. >>> name ="little-five-hello-world"
  10. >>> name.split("-")
  11. ['little', 'five', 'hello', 'world']
  12. >>> name.split("-",2)  #指定分割几次
  13. ['little', 'five', 'hello-world']
  14. >>>

替代 —>replace

  1. #替代
  2. >>> name ="little-five"
  3. >>> name.replace("l","L")
  4. 'LittLe-five'
  5. #也可以指定参数，替换几个
  6. >>> name.replace("i","e",2)
  7. 'lettle-feve'
  10. 　　　　清除空白 --> strip()、lstrip()、rstrip()
  12. #去除空格
  13. >>> name =" little-five "
  15. #去除字符串左右两边的空格
  16. >>> name.strip()
  17. 'little-five'
  19. #去除字符串左边的空格
  20. >>> name.lstrip()
  21. 'little-five '
  23. #去除字符串右边的空格
  24. >>> name.rstrip()
  25. ' little-five'

替换 —>makestran 、translate

  1. #进行一一替换
  3. >>> a ="wszgr"
  4. >>> b="我是中国人"
  5. >>> v =str.maketrans(a,b) #创建对应关系，并且两个字符串长度要求一致
  6. >>> info ="I'm a Chinese people,wszgr"
  7. >>> info.translate(v)
  8. "I'm a Chine是e people,我是中国人"

4、列表 —>list类

列表是由一系列特定元素顺序排列的元素组成的，它的元素可以是任何数据类型即数字、字符串、列表、元组、字典、布尔值等等，同时其元素也是可修改的。

其形式为：

  1. 1 names = ['little-five","James","Alex"]
  2. 2 #或者
  3. 3 names = list(['little-five","James","Alex"])

索引、切片

  1. #索引-->从0开始，而不是从一开始
  2. name =["xiaowu","little-five","James"]
  3. print(name[0:-1])
  6. #切片-->负数为倒数第几个，其为左闭右开，如不写，前面表示包含前面所有元素,后面则表示后面所有元素
  7. m1 =name[1:]
  8. print(m1)
  9. #输出为-->['little-five', 'James']
  10. m2 =name[:-1]
  11. print(m2)
  12. #输出为-->['xiaowu', 'little-five']

追加–>append()

  1. #追加元素-->append()
  2. name =["xiaowu","little-five","James"]
  3. name.append("alex")
  4. print(name)
  6. #输出为--》['xiaowu', 'little-five', 'James', 'alex']

拓展–>extend()

  1. #扩展--》其将字符串或者列表的元素添加到列表内
  2. #一、将其他列表元素添加至列表内
  3. name =["xiaowu","little-five","James"]
  4. name.extend(["alex","green"])
  5. print(name)
  6. #输出为-->['xiaowu', 'little-five', 'James', 'alex', 'green']
  8. #二、将字符串元素添加到列表内
  9. name =["xiaowu","little-five","James"]
  10. name.extend("hello")
  11. print(name)
  12. #输出为-->xiaowu', 'little-five', 'James', 'alex', 'green', 'h', 'e', 'l', 'l', 'o']
  14. #三、将字典元素添加至列表内，注：字典的key。
  15. name =["xiaowu","little-five","James"]
  16. name.extend({ "hello":"world"})
  17. print(name)

注：扩展extend与追加append的区别：–>前者为添加将元素作为一个整体添加，后者为将数据类型的元素分解添加至列表内。例：

  1. #extend-->扩展
  2. name =["xiaowu","little-five","James"]
  3. name.extend(["hello","world"])
  4. print(name)
  5. 输出为-->['xiaowu', 'little-five', 'James', 'hello', 'world']
  7. #append -->追加
  8. name.append(["hello","world"])
  9. print(name)
  10. 输出为 -->['xiaowu', 'little-five', 'James', ['hello', 'world']]

insert() —>插入

  1. 1 #insert（）插入-->可以指定插入列表的某个位置，前面提到过列表是有序的
  2. 2 name =["xiaowu","little-five","James"]
  3. 3 name.insert(1,"alex") #索引从0开始，即第二个
  4. 4 print(name)

pop() —>取出

  1. #pop()--取出，可将取出的值作为字符串赋予另外一个变量
  2. name =["xiaowu","little-five","James"]
  3. special_name =name.pop(1)
  4. print(name)
  5. print(special_name,type(special_name))
  7. #输出为：['xiaowu', 'James']
  8. # little-five <class 'str'>

remove()–>移除、del —>删除

  1. #remove -->移除，其参数为列表的值的名称
  2. name =["xiaowu","little-five","James"]
  3. name.remove("xiaowu")
  4. print(name)
  6. #其输出为：['little-five', 'James']
  8. #del -->删除
  9. name =["xiaowu","little-five","James"]
  10. #name.remove("xiaowu")
  11. del name[1]
  12. print(name)
  14. #其输出为：['xiaowu', 'James']

sorted()–>排序，默认正序，加入reverse =True，则表示倒序

  1. #正序
  2. num =[11,55,88,66,35,42]
  3. print(sorted(num)) -->数字排序
  4. name =["xiaowu","little-five","James"]
  5. print(sorted(name)) -->字符串排序
  6. #输出为：[11, 35, 42, 55, 66, 88]
  7. #    ['James', 'little-five', 'xiaowu']
  9. #倒序
  10. num =[11,55,88,66,35,42]
  11. print(sorted(num,reverse=True))
  12. #输出为：[88, 66, 55, 42, 35, 11]

5、元组 —>tuple类
　　　　元组即为不可修改的列表。其于特性跟list相似。其使用圆括号而不是方括号来标识。

  1. #元组
  2. name = ("little-five","xiaowu")
  3. print(name[0])

6、字典 —>dict类
　　　 字典为一系列的键-值对，每个键值对用逗号隔开，每个键都与一个值相对应，可以通过使用键来访问对应的值。无序的。

键的定义必须是不可变的，即可以是数字、字符串也可以是元组，还有布尔值等。

而值的定义可以是任意数据类型。

  1. #字典的定义
  2. info ={ 
  3.     1:"hello world",  #键为数字
  4.     ("hello world"):1, #键为元组
  5.     False:{  
  6.         "name":"James"
  7.     },
  8.     "age":22
  9. }

遍历 —>items、keys、values

  1. info ={ 
  2.    "name":"little-five",
  3.    "age":22,
  4.    "email":"99426353*@qq,com"
  5. }
  6. #键
  7. for key in info:
  8.     print(key)
  9. print(info.keys())
  10. #输出为：dict_keys(['name', 'age', 'email'])
  12. #键值对
  13. print(info.items())
  14. #输出为-->dict_items([('name', 'little-five'), ('age', 22), ('email', '99426353*@qq,com')])
  16. #值
  17. print(info.values())
  18. #输出为：dict_values(['little-five', 22, '99426353*@qq,com'])

7、集合 —>set类
　　　 关于集合set的定义：在我看来集合就像一个篮子，你可以往里面存东西也可往里面取东西，但是这些东西又是无序的，你很难指定单独去取某一样东西；同时它又可以通过一定的方法筛选去获得你需要的那部分东西。故集合可以 创建、增、删、关系运算。

集合的特性：

1、去重

2、无序

3、每个元素必须为不可变类型即（hashable类型，可作为字典的key）。

创建：set、frozenset

  1. #1、创建，将会自动去重,其元素为不可变数据类型，即数字、字符串、元组
  2. test01 ={ "zhangsan","lisi","wangwu","lisi",666,("hello","world",),True}
  3. #或者
  4. test02 =set({ "zhangsan","lisi","wangwu","lisi",666,("hello","world",),True})
  6. #2、不可变集合的创建 -->frozenset()
  7. test =frozenset({ "zhangsan","lisi","wangwu","lisi",666,("hello","world",),True})

增： add、update

  1. #更新单个值 --->add
  2. names ={ "zhangsan","lisi","wangwu"}
  3. names.add("james") #其参数必须为hashable类型
  4. print(names)
  6. #更新多个值 -->update
  7. names ={ "zhangsan","lisi","wangwu"}
  8. names.update({ "alex","james"})#其参数必须为集合
  9. print(names)

删除：pop、remove、discard

  1. #随机删除 -->pop
  2. names ={ "zhangsan","lisi","wangwu","alex","james"}
  3. names.pop()
  4. print(names)
  6. #指定删除，若要删除的元素不存在，则报错 -->remove
  7. names ={ "zhangsan","lisi","wangwu","alex","james"}
  8. names.remove("lisi")
  9. print(names)
  11. #指定删除，若要删除的元素不存在，无视该方法 -->discard
  12. names ={ "zhangsan","lisi","wangwu","alex","james"}
  13. names.discard("hello")
  14. print(names)

关系运算：交集 & 、并集 | 、差集 - 、交差补集 ^ 、 issubset 、isupperset

比如有两个班英语班和数学班，我们需要统计这两个班中报名情况，例如既报名了英语班有报名数学班的同学名字等等，这时候我们就可以应用到集合的关系运算：

  1. english_c ={ "ZhangSan","LiSi","James","Alex"}
  2. math_c ={ "WangWu","LiuDeHua","James","Alex"}
  4. #1、交集-->  in a and in b
  5. #统计既报了英语班又报了数学班的同学
  6. print(english_c & math_c)
  7. print(english_c.intersection(math_c))
  8. #输出为：{ 'Alex', 'James'}
  10. #2、并集--> in a or in b
  11. #统计报名了两个班的所有同学
  12. print(english_c | math_c)
  13. print(english_c.union(math_c))
  14. #输出为：{ 'James', 'ZhangSan', 'LiuDeHua', 'LiSi', 'Alex', 'WangWu'}
  16. #3、差集--> in a not in b
  17. #统计只报名英语班的同学
  18. print(english_c - math_c)
  19. print(english_c.difference(math_c)) 
  20. #输出为：{ 'LiSi', 'ZhangSan'}
  22. 4、交差补集 
  23. #统计只报名一个班的同学
  24. print(english_c ^ math_c)
  25. #输出为：{ 'LiuDeHua', 'ZhangSan', 'WangWu', 'LiSi'}

判断两个集合的关系是否为子集、父集 —> issubset 、isupperset

  1. #5、issubset-->n 是否为 m 的子集
  2. # issuperset --> n 是否为 m 的父集
  3. n ={ 1,2,4,6,8,10}
  4. m ={ 2,4,6}
  5. l ={ 1,2,11}
  7. print(n >= m)
  8. #print(n.issuperset(m)) #n 是否为 m的父集
  9. #print(n.issuperset(l))
  10. print(m <=n)    
  11. #print(m.issubset(n)) #m 是否为 n的子集

如果对软件测试有兴趣，想了解更多的测试知识，解决测试问题,以及入门指导，帮你解决测试中遇到的困惑，我们这里有技术高手。如果你正在找工作或者刚刚学校出来，又或者已经工作但是经常觉得难点很多，觉得自己测试方面学的不够精想要继续学习的，想转行怕学不会的， 都可以加入我们在这里插入图片描述
，群内可领取最新软件测试大厂面试资料和Python自动化、接口、框架搭建学习资料！

发表评论

表情：
评论列表 （有 0 条评论，408人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Python 基本数据类型

    目录   数据类型 整数 浮点数 字符串 布尔值 空值 序列 sequence 序列 空序列 元素的引用 其他引用方式 尾部元素引用 字符串是元组

    Dear 丶Dear 丶/ 0 赞/ 581 阅读

    相关 Python3基本数据类型

    Python中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在Python中，变量就是变量，它没有类型，我们所说的“类型”是变量所指的内存中对象的

    青旅半醒青旅半醒/ 0 赞/ 358 阅读