将学习者分类python代码 分类 python

Python是做自动化工作首选的一门语言，与更复杂的语言相比，Python 非常便于快速学习、语法很少，具有良好的 可读性，即使测试工程师们没有丰富的编码经验，也能快速学会；Python 的极简风格对于测试自动化具有诸多优势，测试步骤在本质上是呈线性的、一 次执行一个，按顺序执行，配合丰富的插件，非常适合测试脚本的开发。

本文就重点讲解一下python中常见数据类型：

• Number--数字类型
• String--字符串类型
• List--列表类型
• Tuple--元组类型
• set--集合类型
• Dict--字典类型
• Bool--布尔类型

一、数字类型

python中的Number数字类型，主要分为整形、浮点型和复数三种

1、整形数据--int

在python中是精确的，想存储多大就是多大，是和内存大小相关，如：age=124556666666666666

2、浮点型数据--float--decimal.Decimal

默认的存放精度是17位，在范围内保证数据准确性，超过了就不精确了。

• salary = 1234.123456789012
• salary = 1234.12345678901234

如果想提升精度，需要使用decimal模块（提升到30位精度）

import decimal
decimal.getcontext().prec=30  #提升精度到30位
aa = decimal.Decimal(10)/decimal.Decimal(3)
输出：Decimal('3.33333333333333333333333333333')
bb = 10/3
输出：3.3333333333333335

3、复数--complex

复数是有实部和虚部组成的，aa = x + yj

• aa.real：获取复数的实部
• aa.imag：获取复数的虚部

二、布尔类型

布尔类型只有两个值False和True

flag = False 
flag = True

在python中下面的数据都会被认为是False：

• None

if None:
    print("aa")
else:
    print("bb")
#输出结果为bb

print(bool())

• False

if False:
    print("aa")
else:
    print("bb")
#输出结果为bb

print(bool(False))

• zero of any numeric type, for example, 0, 0.0, 0j

if 0:
    print("aa")
else:
    print("bb")
#输出结果为bb

print(bool(0),bool(0.0),bool(0j))

• any empty sequence, for example, '', (), []

if []:
    print("aa")
else:
    print("bb")
#输出结果为bb

print(bool(""),bool(()),bool([]),bool({}))

• any empty mapping, for example, {}

if {}:
    print("aa")
else:
    print("bb")
#输出结果为bb

print(bool(""),bool(()),bool([]),bool({}))

三、序列类型

1、序列类型简介

序列类型其实也是一种容器类型，可以放多个数据，里面放的不同类型的数据就叫成员或者元素。

序列类型包括：

• 字符串类型String
• 列表list
• 元组tuple

系列类型的特点：

• 序列类型的成员是有序的（怎么放进去的怎么拿出来）
• 可以通过下标（索引index，就是每个元素在序列中的位置的编号，一般是从0开始）访问到序列一个或者多个元素或者成员
• 通过下标可以访问一个或者多个元素
• 访问多个元素，我们称为切片

2、序列类型通用运算符

序列中通用的运算符：str1 = "abcdefg",str2 ='123456'

• x in str1：元素（成员）x是在字符串中，x是字符串str1的一个成员？如果是返回True，否则返回False。

'a' in str1

• x not in str1 ：元素x不在str1中，x不是字符串的一个成员？如果不在返回True，否则返回False。

'a' not in str1

• str1 + str2：str1和str2都是序列,+就是拼接作用

print(str1+str2)

• str1 * n：n是一个整形的数据，将str1进行复制2份

print(str1*2)

• str1[m]:m就是索引，范围从0到str1元素个数-1；str1[0]-->a;str1[7]-->string index out of range；str1[-2]

序列中的元素：1 2 3 4 5 6
序列元素索引：0 1 2 3 4 5
支持逆向索引：-6 -5 -4 -3 -2 -1

• str1[start:end:step]：切片的使用，start开始的位置索引，end表示结束位置，step为步进。

str1[0:3]->abc,左闭右开（可以取到0，但是取不到3），步进step默认是1
str1[0:3:2]->ac,步进改为了2，各一个取一个值，start和end还是左闭右开的
str1[:]->切片所有的值
str1[0:6]->'abcdef'
str1[0:7]->切片所有的值
str1[::-1]->逆向切片所有
str1[-4:-2]->de
str1[2:4:-1]->空
str1[4:2:-1]->ed

2、序列类型通用方法

• len(str1):返回序列的元素的个数（长度）

str1 = 'abcdefg'
str2 = '123456'
str3 = 'abcabcabc'

len(str1)

• min(str1)：获取指定的序列中的最小元素（按照大小进行比较），元素必须可以比较
• 对于字符来说，比较多是ascii码的大小（A-65，a-97）
• 对于数字来说，比较的就是数字的大小

str1 = 'abcdefg'
str2 = '123456'
str3 = 'abcabcabc'

min(str1)
max(str1)

• max(str1)：获取指定的序列中的最大值（按照大小进行比较），元素必须可以比较
• str1.index(value):查找value值在str1序列中的索引（位置序号-1）
• value值可以是字符串、也可以是数字、还可以是序列，返回对应的字符串、数字所在的索引
• value值是多个元素的序列的话，返回的是value的首字符在大串中的第一次出现的索引

str1 = 'abcdefg'
str2 = '123456'
str3 = 'abcabcabc'

str1.index("a")
str2.index('2')
str3.index("ca")

• str1.index(value,start,end):在指定的范围内（start到end），查找value的值，返回索引

str1 = 'abcdefg'
str2 = '123456'
str3 = 'abcabcabc'

str3.index("ca",4,8)

• str1.count(value):查str1序列中指定的value值出现的次数，返回的就是一个整形数据

str1 = 'abcdefg'
str2 = '123456'
str3 = 'abcabcabc'

str1.count('a')

四、字符串

1、字符串定义

字符串是由 ""及 ''圈起来的一串数字或者字符，并且字符串是支持转义的，转义符号(t:tab键，会有4个空格；n:回车换行；:表示是一个反斜杠)

• 字符串的截取（索引和切片）:str1[start:end:step]
• 正向索引范围是从0到字符串长度-1
• 反向索引范围是（-字符串长度）到-1
• +表示字符串的连接
• *表示字符串的复制

2、自然字符串

将具备转义功能字符全部当作普通字符串来用，使用r或者R来修饰字符串

str1 = r"asfasdfasdt nafasdfasdfasdfas"

3、多行显示（续行）

一行中字符太多了，写不开了

str1= 'asdfasdfasdf 
asdfasdfasdfasdfasf 
asdfasdfasfasdfasfasdf'

str2='asdfasdfasdfasd' 
'asdfasdfasdfasdfasdf' 
'asdfasdfasdfas'

str3 = """
asdfasdfasdfasdfasdfasdf
asfasdfas
asdfasdf
"""

4、注意事项：

• python没有字符类型，一个字符可以理解为长度为1的字符串
• 可以进行转义，使用r或者R可以让不发生转义，这就是自然字符串的用法
• 字符串是不允许被改变的
• 字符串可以用+运算符连接在一起，用*运算符重复
• Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
• Python中的字符串不能改变
• 如果想字符串反转显示：则str[::-1]
• %格式化 - 执行字符串格式

>>> a=12
>>> b=23.5
>>> print(a)
12
>>> print("%d,%f"%(a,b))
12,23.500000
>>> print("输出的数据是：%d,%f"%(a,b))
输出的数据是：12,23.500000
>>> print("输出的数据是：%d,%3f"%(a,b))
输出的数据是：12,23.500000
>>> print("输出的数据是：%d,%9f"%(a,b))
输出的数据是：12,23.500000
>>> print("输出的数据是：%d,%12f"%(a,b))
输出的数据是：12,   23.500000
>>> print("输出的数据是：%d,%3f"%(a,b))
输出的数据是：12,23.500000
>>> print("输出的数据是：%d,%5.3f"%(a,b))
输出的数据是：12,23.500
>>> print("输出的数据是：%5d,%5.3f"%(a,b))
输出的数据是：   12,23.500
>>> print("输出的数据是：%1d,%5.3f"%(a,b))
输出的数据是：12,23.500
>>> print("输出的数据是：%d,%5.3f"%(a,b))
输出的数据是：12,23.500
>>> print("输出的a是：%3d"%a)
输出的a是： 12
>>> print("输出的a是：%8d"%a)
输出的a是：      12

五、列表

1、列表的简介

列表是序列类型，有序、可索引、可切片，可变、可重复，也可以理解为一个容器类型，所有基础数据类型都可以存入（数字、字符串、列表、元组、字典等） 。

列表是以[]进行定义的，以,进行元素的分隔。

list1 = [1,2,3,4,5,6]
list2 = ["a","b","c","d"]
list3 = [1,"a",2,"b"]
list4 = [list1,list2]

• 列表是可以被索引或者切片的，被切片之后返回一个包含切片元素的新的列表(留个疑问，列表不是可变的吗？)

list1 = [1,2,3,4,5,6]
print(list1[1:3])
print(list1)

• 列表也可以进行正向的索引，可以进行逆向索引

list1 = [1,2,3,4,5,6]
print(list1[1:3])
print(list1[::-1])
print(list1[:-1])
print(list1[-4:])

• 列表的+拼接和列表的*复制

list1 = [1,2,3,4,5,6]
list2 = ["a","b","c","d"]
list3 = [1,"a",2,"b"]
list4 = [list1,list2]
# [1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd']
print(list1+list2)
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
print(list1 * 3)

• 列表元素是可以变化的：可以通过索引改变某一个元素，直接给基础数据类型（数字、字符串）；可以通过切片该表一个或者多个元素，通过列表给值

list1 = [1,2,3,4,5,6]
print(id(list1))
#可以通过索引改变某一个元素，直接给基础数据类型（数字、字符串）
list1[0]=12
print(id(list1))
print(list1)
可以通过切片该表一个或者多个元素，通过列表给值
list1[:]=[222]
print(list1)
list1[:]=[2,3,4,56,7]
print(list1)
#可以实现删除某些元素
list[2:3]=[]

2、列表中常用的方法

• list.index(value)：查找list列表中value元素所在的位置（索引）

list1 = [1,2,3,4,5,6]
print(list1.index(4))

• list.append(value)：往列表中追加元素，只能追加到列表的末尾处

list1 = [1,2,3,4,5,6]
#append()的返回值是空
print(list1.append())
#list1是可变的，其值已经被改变了
print(list1)

• list.insert(index,value):在列表的指定的位置处，插入一个新的值,原来该位置处的值往后移动

list1 = [1,2,3,4,5,6]
list1.insert(2,12)
#[1, 2, 12, 3, 4, 5, 6]
print(list1)
#返回的事insert方法的返回值，None
#print(list1.insert(2,12))
#如果是超出了list的索引号，插入在最后的位置
#print(list1.insert(8,12))

• list.extend(list2):将list2中的元素依次添加到list列表的末尾位置（前面的append、insert方法是将列表整个加到新列表中）

list1 = [1,2,3,4,5,6]
list2 = ["a","b","c","d"]
# [1, 2, ['a', 'b', 'c', 'd'], 3, 4, 5, 6]
# list1.insert(2,list2)
#[1, 2, 3, 4, 5, 6, ['a', 'b', 'c', 'd']]
# list1.append(list2)
# print(list1)
#extend方法将一个列表中的元素分别加载到另外一个列表中
list1.extend(list2)
print(list1)

• list.count(value):统计list列表中的出现value元素的次数

list1 = [1,2,3,4,5,6,1,1,1,2,2,3,4,6]
print(list1.count(1))

• list.reverse():列表元素逆序（反过来）

list1 = [1,2,3,4,5,6,1,1,1,2,2,3,4,6]
print(list1.reverse())
print(list1)

• list.remove(value):将指定的value元素从list列表中移除，只移除在列表中出现的第一个元素

list1 = [1,2,3,4,5,6,1,1,1,2,2,3,4,6]
# list1[2:4]=[]
# print(list1)

#可以通过remove方法实现删除一个元素,是对列表本身做的操作
list1.remove(1)
print(list1)
#ValueError: list.remove(x): x not in list
list1.remove(7)
print(list1)

• del list[index]：直接删除指定索引号的元素，每次只能删除一个

list1 = [1,2,3,4,5,6,1,1,1,2,2,3,4,6]
del list1[0]
print(list1)

• list.pop(index):弹出指定索引的元素，并返回该元素；如果不指定index索引的话，弹出最后一个元素

list1 = [1,2,3,4,5,6,1,1,1,2,2,3,4,6]
# 删除指定的元素并返回
# print(list1.pop(0))
# print(list1.pop())
# print(list1)

#结合append和pop方法实现栈内存特点的模拟（先进后出）
#压栈的过程
list4=[]
list4.append(1)
list4.append(2)
list4.append(3)
list4.append(4)
list4.append(5)
print(list4)
#弹栈的过程
print(list4.pop())
print(list4.pop())
print(list4.pop())
print(list4.pop())
print(list4.pop())

六、元组

元组是序列类型，有序、可索引、可切片、可重复、不可以修改，一旦元素被存储，以后就不能修改、删除了

1、元组的定义

• 元组是用()来定义的，多个元素之间是用,分隔的，至少要有一个逗号

tuple1 = (10,)
#可以定义空的元组
tuple2=()
#也可以通过set创建元组或者空元组
tuple3 = tuple()
tuple = tuple("avasdfa")
#<class 'int'>
print(type(tuple1))
print(tuple1)

2、元组的特点

• 元组是容器类型，其中可以放数字、字符串、列表、元组

tuple1 = (10,"aaa",[12,23],(12,3))
print(type(tuple1))
print(tuple1)

• 元组的元素是可以重复的

tuple1 = (10,10,10,"aaa","aaa",[12,23],(12,3))
print(type(tuple1))
print(tuple1)

• 元组是不可修改的，数字、字符串元素不允许更改；如果是列表则列表（地址）不允许修改，但是可以该列表中数据

tuple1 = (10,10,10,"aaa","aaa",[12,23],(12,3))

print(tuple1[0])
print(tuple1[:])
print(tuple1[:-1])
print(tuple1[-7:])
# 'tuple' object does not support item assignment
# tuple1[0] = 12
tuple1[5][0] =22
print(tuple1[5][0])

• 元组也支持连接+及复制*的使用

tuple1 = (10,10,10,"aaa","aaa",[12,23],(12,3))
tuple2 = tuple1 + tuple1
print(tuple2 * 2)

3、元组和其他序列的区别

为什么区分列表和元组？

• 最好使用不可变类型变量的一个情况是，如果在维护一些敏感的数据，并且不想数据被调用的函数篡改。
• 需要可变类型参数的一个例子，如果在管理动态数据集合时，你需要先把它们创建出来，逐渐地或者不定期的添加它们，或者有时还要移除一些单个的元素。

序列类型为数据的顺序存储提供了几种机制？

• 字符串是最常用的数据载体,无论是用于给用户显示,存贮到硬盘,通过网络传输,还是作为一个多源信息的容器
• 列表和元组提供了容器存储能力,允许简单的操作和访问多个对象,无论它们是Python 的对象还是用户自定义的对象
• 单一元素或一组元素可以通过持续有序地索引偏移进行切片操作来访问

七、set集合

集合（set）是一个无序、不重复元素的数据类型

1、set集合的创建

#定义一个空的set集合
setKong = set()
#元素不能重复，会将重复的除去掉
studentName = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
studentSex = set("男女")
#输出和输入是不一致的
print(studentName)
print(studentSex)

2、set集合的基本用法

• 增加集合元素：add

studentSex = {"男","女"}
studentSex.add("男女")
#{'男', '男女', '女'}
print(studentSex)

• 清除集合元素：clear

studentSex = {"男","女"}
studentSex.clear()
#set()
print(studentSex)

• 浅拷贝集合元素：copy

studentSex = {"男","女"}
ss = studentSex.copy()
#{'男', '女'}
print(ss)

• 差集运算：difference

studentSex = {"男","女"}
ss = studentSex.copy()
#两个集合的差集是set()
print(studentSex.difference(ss))
#相当于
print(studentSex-ss)

• 弹出集合元素：pop，无参，只能弹出集合的最后一个元素并返回该元素

studentSex = {"男","女"}
print(studentSex.pop())
print(studentSex)

• 移除指定的元素：remove，有参数，无返回值

studentSex = {"男","女"}
#无返回值，显示None
print(studentSex.remove("男"))
#移除后剩下{"女"}
print(studentSex)

• 更新集合元素：update

studentSex = {"男","女"}
print(studentSex.update("好"))
#{'好', '男', '女'}
print(studentSex)

• 成员关系测试

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}

print(student)   # 输出集合，重复的元素被自动去掉

# 成员测试
if('Rose' in student) :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中’)

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam') 
print(a)
print(a - b)     # a和b的差集
print(a | b)     # a和b的并集
print(a & b)     # a和b的交集
print(a ^ b)     # a和b中不同时存在的元素

八、字典

字典是一个无序的数据集合、是一种映射类型，并且字典是以键、值对组成，通过键来取值的（不能通过索引或者切片来取）

1、字典的定义

• 字典是通过{}来定义的
• 字典是以键、值对组成
• 字典的键是无序的、不允许重复的（set）
• 字典的值没有这种限制

set1 = {} #空的大括号其实定义的是字典
set2 = {1,2,3,4}#空的大括号其实定义的是set集合
#就是想定义一个空的set集合，怎么做？
set3 = set()
print(type(set3))
print(set3)

#字典的定义
dict11 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}

print(type(dict11))
print(dict11)
print(dict11["黄晓明"])
#通过这种方式是可以修改键的值的
dict11["黄晓明"]="angle baby"

#其他的字典定义方式
dict1 = {"a":1,"b":2,"c":3}
print(dict1)
print(dict1.items())
# dict()是一个工厂类方法
dict2 = dict([('a', 1), ('b', 2), ('c', 3)])
print(dict2)

dict3 = dict(a=1,b=2,c=3)
print(dict3)

dict4 = dict(zip(('a','b','c'),(1,2,3)))
print(dict4)

dict5 = {}.fromkeys(('a','b','c'))
dict5['a']=1
print(dict5)

2、字典的常用方法

• dict1.keys()：获取字典的所有的键

dict1 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}
print(dict1.keys())
print(type(dict1.keys())

• dict1.values()：获取字典的所有值

dict1 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}
print(dict1.values())
print(type(dict1.values()))

• dict1.items():获取的是字典的所有键和值组成的元组的集合

dict1 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}
print(dict1.items())
print(type(dict1.items()))

• dict1.clear()：清空字典内容，返回None，字典dict1为{}

dict1 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}
print(dict1.clear())
print(dict1)

• dict1.copy()：浅拷贝功能，其实就是复制一个副本

dict1 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}
dict2 = dict1.copy()
print(dict2)
print(dict1)

• {}.fromkeys(seq,value=None)：将seq序列种的数据作为字典的键，value作为其默认值返回

dict4 = {}.fromkeys({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'},'a')
print(dict4)

• dict1.get(key,default=None):获取字典中指定key所对应的value，如果key不在字典中，则返回None,比直接通过dict[""]更安全

dict4 = {}.fromkeys({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'},'a')
print(dict4.get('Rose11'))
print(dict4.get('Rose11','字典中没有这个键'))
#KeyError: 'Rose11'
# print(dict4["Rose11"])

• dict1.pop(key[,default]) :如果字典中存在key，删除并返回key对应的vuale；如果key不存在，且没有default值，则keyerror异常

dict4 = {}.fromkeys({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'},'a')
print(dict4.pop("RR","dd"))
print(dict4)

• dict1.update(bdict) ：将字典bdict的键值对添加到字典dict1中。

dict1 = {"黄晓明":"杨颖","文章":"马伊利","邓超":"孙俪","文章":"姚笛"}
dict4 = {}.fromkeys({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'},'a')
print(dict4.update(dict1))
print(dict4)