Python中常用的数据类型:
作者:互联网
Python中常用的数据类型:
-
int:数字:主要用于运算。1 ,2,3…
-
float:浮点
python保留小数位的方法
方法一:format函数 print('{:.3f}'.format(1.23456)) 结果:1.235 print(format(1.23456, '.2f')) 结果:1.23 正如上面代码所示,format有不同用法,前者使用了占位符{},使用占位符可以同时输出多个,后者一次只能输出一个,需要注意的是占位符中的冒号不能丢。笔者推荐使用占位符+format输出。 print('{:.3f} {:.2f}'.format(1.23456, 1.23456)) 结果:1.235 1.23 方法二:'%.xf'方法 print('%.2f' % 1.23456) 结果:1.23 方法三:round()函数 print(round(1.23456,3)) 结果:1.235 print(round(2.355,2)) 结果:2.35 print(round(2.5)) 结果:2 print(round(3.5))
-
str:简单少量的储存数据,并进行相应的操作。name = ‘this is a python’
-
bool:判断真假:True, False.
-
Tuple-元祖:只读,不能更改。(1,‘alex’)****
-
list:大量有序数据,[1,‘ses’,True,[1,2,3],{‘name’:‘jinxin’}]****
-
dict:大量数据,且是关联性比较强的数据{}
-
bytes:bytes类型,是python3.新增加的数据类型
一常见字符串str方法。
1:casefold()将所有的字符转化为小写:
name = "ZhangSan"
print("{0}".format(name.casefold()))
打印结果:zhangsan
2:capitalize()字符串首字母大写其他字符都小写:
name = "zhangSan"
name = name.capitalize()
print("{0}".format(name))
# 打印结果:Zhangsan
3:center()字符串宽度填充:
name = "zhangSan"
name = name.center(12)
print("{0}".format(name))
# 打印结果:' Zhangsan '
# 默认以空格填充
name = "zhangSan"
name = name.center(12, "#")
print("{0}".format(name))
# 打印结果:'##Zhangsan##'
# 以‘#’填充
4:count()统计字符在字符串中出现的次数:
name = "zhangSan"
num = name.count('S')
print("{0}".format(num))
# 打印结果:1
name = "zhangSan"
num = name.count('S', 0, 3) #从0,1,2索引里找
print("{0}".format(num))
#打印结果:0
5:encode()字符串编码:
name = "zhangsan"
name = name.encode('gbk')
print("{0}".format(name))
# 打印结果:b'zhangsan'
6:startswith()判断字符串以某个字符串开头,返回boolean类型:
name = "zhangsan"
isTrue = name.startswith("zh")
print(isTrue)
# 打印结果:True
7:endswith()判断字符串以某个字符串结尾,返回boolean类型:
name = "zhangsan"
isTrue = name.endswith("san")
print(isTrue)
# 打印结果:True
8:find()在字符串中查找指定字符串,找不到时返回-1:
rfind反向查找
name = "zhangsan"
isIn = name.find("an")
print(isIn)
# 打印结果:2
isIn = name.find("an",4)#第二个值为开始的索引值
# 打印结果:6
# 返回字符串开始的下标
9:format()格式化输出字符串:
name = "{} {} zhangsan"
#"{} {}"是占位符,用下边format()里边的参数填充
name = name.format('I', 'am')
print(name)
# 打印结果:I am zhangsan
10:index()在字符串中查找指定的字符串,返回索引找不到时直接报错:
rindex反向查找
name = "zhangsan"
isIn = name.index('a')
print(isIn)
#打印结果:2
11:join()字符串连接:
name = "zhangsan"
name = '*'.join(name)
print(name)
# 打印结果:z*h*a*n*g*s*a*n
12:isalnum()判断字符串是否只包含字母数字:
name = "zhangsan1"
isTrue = name.isalnum()
print(isTrue)
# 打印结果:True
name = "zhangsan1*"
isTrue = name.isalnum()
print(isTrue)
# 打印结果:False
13:isalpha()判断是否只包含字母:
name = "zhangsan"
isTrue = name.isalpha()
print(isTrue)
# 打印结果:True
name = "zhangsan1"
isTrue = name.isalpha()
print(isTrue)
# 打印结果:False
14:isdigit()判断字符串只由数字构成:
name = "1234"
isTrue = name.isdigit()
print(isTrue)
# 打印结果:True
name = "zhangsan1234"
isTrue = name.isdigit()
print(isTrue)
# 打印结果:False
15:isspace()判断字符串是否是空格:
name = " "
isTrue = name.isspace()
print(isTrue)
# 打印结果:True
name = "zhang san"
isTrue = name.isspase()
print(isTrue)
# 打印结果:False
16:isupper()判断字符串是否全是大写字符:
name = "ZHANGSAN"
isTrue = name.isupper()
print(isTrue)
# 打印结果:True
17:lower()将所有的大写字符转为小写字符:
name = "ZHANGSAN"
name = name.lower()
print(name)
# 打印结果:zhangsan
18:lstrip()去除字符串左边的空格:
name = " zhangsan "
name = name.lstrip()
print(name)
# 打印结果:zhangsan
19:rstrip()去除字符串右边的空格:
name = " zhangsan "
name = name.rstrip()
print(name)
# 打印结果: zhangsan
20:strip()去除字符串2边的空格:
name = " zhangsan "
name = name.strip()
print(name)
# 打印结果:zhangsan
21:replace()字符串替换:
name = "zhangsan"
name = name.replace("zhang", "li")
print(name)
# 打印结果:lisan
22:split()字符串分割,默认是空格:
name = "zhang san"
name = name.split()
print(name)
# 打印结果:['zhang', 'san']
23:add()在字符串后边添加字符串:
name = "zhang"
name = name.__add__("san")
print(name)
# 打印结果:zhangsan
24:contains()判断指定字符串是否包含在字符串中:
name = "zhangsan"
isTrue = name.__contains__("san")
print(isTrue)
# 打印结果:True
25:eq()判断字符串是否相等:
name = "zhangsan"
name1 = "zhangsan"
isEq = name.__eq__(name1)
print(isEq)
# 打印结果:True
二读取字符串中的某些字符
s = “Hello, my name is Alex,golden king.”
字符串特性:
1 按照从左到右的顺序定义字符集合,下标从0开始顺序访问,有序
2 不可变,字符串是不可变的,不能像列表⼀样修改其中某个元素,所有对字符串的修改操作其实都是相当于生成了⼀份新数据。
3 可进行切片操作
切片:就是通过索引(索引:索引:步长)截取字符串的一段,形成新的字符串(原则就是顾头不顾尾)。
s = 'abcdefghigklmn'
print(s[0:3]) #abc
print(s[2:5]) #cde
print(s[0:]) #默认到最后
print(a[0:len(a)])
print(s[0:-1]) # -1 是列表中最后一个元素的索引,但是要满足顾头不顾腚的原则,所以取不到K元素
print(s[0:5:2]) #加步长 ace
print(s[5:0:-2]) #反向加步长
print(s[::2])#返回acegikm
三元祖类型 tuple
定义元组:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改
如果要定义一个空的tuple,可以写成()
:
但是,要定义一个只有1个元素的tuple,如果你这么定义: t = (1),定义的不是tuple,是1
这个数!这是因为括号()
既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1
。
所以,只有1个元素的tuple定义时必须加一个逗号,
,来消除歧义:
t = (1,)
创建元组:
tup = (11, 22, 33, 44, 55)
或
tup = tuple((11, 22, 33, 44, 55))
基本操作:索引,切片,循环,长度,包含
基本函数:
cmp(tuple1,tuple2):比较两个元组元素
len(tuple)计算元组元素个数
max(tuple)返回元组中元素最大值
min(tuple)返回元组中元素最小值
tuple(seq)将列表转换为元组
四列表list
列表是python中的基础数据类型之一,其他语言中也有类似于列表的数据类型,比如js中叫数组,他是以[]括起来,每个元素以逗号隔开,而且他里面可以存放各种数据类型
常用方法
方法 | 意义 |
---|---|
L.index(val, start,end) | 返回对应元素的索引下标, begin为开始索引,end为结束索引,当 value 不存在时触发ValueError错误 |
L.insert(index, obj) | 将某个元素插放到列表中指定的位置,其中,index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。 |
L.count(x) | 返回列表中元素的个数 |
L.remove(x) | 从列表中删除第一次出现在列表中的值 |
L.copy() | 复制此列表(只复制一层,不会复制深层对象),此层发生改变,复制曾也会受到影响 |
L.append(x) | 向列表尾部追加单个元素,当给 append() 方法传递列表或者元组时,会将它们视为一个整体,作为一个元素添加到列表中,从而形成包含列表和元组的新列表。 |
L.extend(lst) | 向列表追加另一个列表,不会把列表或者元祖视为一个整体,而是把它们包含的元素逐个添加到列表中。 |
L.clear() | 清空列表,等同于 L[:] = [] |
L.sort(reverse=False) | 将列表中的元素进行排序,默认顺序按值的小到大的顺序排列 |
L.reverse() | 列表的反转,用来改变原列表的先后顺序 |
L.pop([index]) | 删除索引对应的元素,如果不加索引,默认删除最后元素,有返回值 |
del L[start,end] | 按照索引去删除,也可切片删除没有返回值 |
一,改变list中的值利用索引既可以改变:
L[2]="我是新数据"
二,按切片去改实质是按迭代增加到列表
L [1:4] = ['a','b'] #索引1-3的值改为a,b
已知列表 li=[("s",12),("b",23)]
6.1 按照第二个元素进行从大到小的排序
li.sort(key=lambda x:x[1],reverse=True)
数据转成字典
dict(li)
列表生成式
list = [i for i in range(9)]
print(list)#012345678
五字典dict
字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据。python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的,且key必须是可哈希的。可哈希表示key必须是不可变类型,如:数字、字符串、元组。
创建字典的方法
创建一个空字典 这是最常用的
dict={}
传入可迭代对象
b = dict(zip(['one','two','three'],[1,2,3]))
print(b) #{'one': 1, 'two': 2, 'three': 3}
listRet=list(zip(['one','two','three'],[1,2,3]))
print(listRet) #[('one', 1), ('two', 2), ('three', 3)]
c = dict([('one', 1), ('two', 2), ('three', 3)])
print(c) #{'one': 1, 'two': 2, 'three': 3}
c1 = dict([('one', 1), ('two', 2), ('three', 3),('three', 4),('three', 5)])
print(c1) #如果键有重复,其值为最后重复项的值。
#传入映射对象,字典创建字典
d = dict({'one': 1, 'two': 2, 'three': 3})
print(d)
对字典操作的方法:
增:
第一种:
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic['address'] = "海南"
dic["address1"] = "云南"
print(dic)
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic['li'] = ["a","b","c"]
print(dic)
第二种:
#setdefault()方法: 在字典中添加键值对,如果只有键那对应的值是none,但是如果原字典中存在设置的键值对,则他不会更改或者覆盖。
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic.setdefault('k','v')
print(dic) # {'age': 18, 'name': 'tan', 'sex': 'girle', 'k': 'v'}
dic.setdefault('k','v1')# {'age': 18, 'name': 'tan', 'sex': 'girle', 'k': 'v'}
print(dic)
setdefault() 方法:
setdefault() 方法用来返回某个 key 对应的 value,其语法格式如下:
dictname.setdefault(key, defaultvalue)
说明,dictname 表示字典名称,key 表示键,defaultvalue 表示默认值(可以不写,不写的话是 None)。
当指定的 key 不存在时,setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue,然后再返回 defaultvalue。
也就是说,setdefault() 方法总能返回指定 key 对应的 value:
- 如果该 key 存在,那么直接返回该 key 对应的 value;
- 如果该 key 不存在,那么先为该 key 设置默认的 defaultvalue,然后再返回该 key 对应的 defaultvalue。
删:
第一种:pop()方法:根据key删除键值对,并返回对应的值,如果没有key则返回默认返回值
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic_pop = dic.pop("tan",'无key默认返回值')
print(dic_pop)
del 除键值对 没有返回值
del dic["name"] # 没有返回值。
print(dic)
第二种:
dic_clear = dic.clear() # 清空字典
print(dic,dic_clear) # {} None
popitem():用来随机删除一个键值对
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic.popitem()
改:
第一种:通过键去改
dic = {"name":"tom","age":18,"sex":"male"}
dic["name"]="jom"
print(dic)
第二种:update()方法:将所有的键值对覆盖添加(相同覆盖,没有的添加)
dic = {"name":"tom","age":18,"sex":"male"}
dic2 = {"name":"wu","weight":75}
dic2.update(dic) # 将dic所有的键值对覆盖添加(相同的覆盖,没有的添加)到dic2中
print(dic2)#{'name': 'tom', 'weight': 75, 'age': 18, 'sex': 'male'}
查:
第一种:通过键名查
value1 = dic["name"] # 没有会报错
print(value1)
第二种:通过get()方法去查
value2 = dic.get("key","默认返回值") # 没有可以返回设定的返回值默认defalut=none
print(value2)
其他操作:
items()方法是可迭代的,返回列表,含所有(键,值)元组的列表
keys()方法:得到字典的键,返回列表,可迭代
values()方法:得到字典的值,返回列表 ,可迭代
'key' in dic #若存在则返回True,没有则返回False
dic.keys() #返回⼀个包含字典所有KEY的列表;
dic.values() #返回⼀个包含字典所有value的列表;
dic.items() #返回⼀个包含所有(键,值)元组的列表;
遍历
1、for k in dic.keys():
2、for k,v in dic.items() :
3、for k in dic :# 推荐⽤这种,效率速度最快
info = {
"name":"张勇峰",
"mission": "加油加油",
"website": "www"
}
for k in info:
print(k,info[k])
六set集合
定义:集合是无序的,不重复的数据集合。以下是集合最重要的两点:去重,把一个列表变成集合,就自动去重了。
特性:因为集合中的元素是不可重复的,且无序的,所以不支持索引,切片,连接。集合只支持成员操作符 迭代(for循环)
集合的创建
第一:set({})方法:创建集合
set1 = set({1,2,'marry'})
第二:{}
set2 = {1,2,'marry'}
增
add()
update()方法:迭代着增加
删除
remove()方法:删除一个元素
pop()方法:随机删除一个元素
clear()方法: 清空集合
del属性: 删除集合
交集intersection()
s1 = {1,2,3}
s2 = {2,3,4}
#交集
print('交集: ',s1.intersection(s2))
print('交集: ',s1 & s2)
并集union()
s1 = {1,2,3}
s2 = {2,3,4}
#并集
print('并集: ',s1.union(s2))
print('并集: ',s1 | s2)
差集difference()
s1 = {1,2,3}
s2 = {2,3,4}
print('差集: ',s1.difference(s2)) #s1 - (s1&s2)
print('差集: ',s2.difference(s1)) #s2 - (s1&s2)
对等差分symmetric_difference()
s1 = {1,2,3}
s2 = {2,3,4}
print('对等差分: ',s1.symmetric_difference(s2))
print('对等差分: ',s2^s1)
子集issuperset()
s1 = {1,2}
s2 = {1,2,3}
print(s1.issuperset(s2))
print(s1.issubset(s2))
判断两个集合是否相交isdisjoint
s1 = {1,2}
s2 = {1,2,3}
print(s1.isdisjoint(s2))
七enumerate枚举是同时获得索引和值
enumerate:枚举,对于一个可迭代的(iterable)/可遍历的对象(如列表、字符串),enumerate将其组成一个索引序列,利用它可以同时获得索引和值。
li = ['marry','男神','女神','tim','吴东坡']
for i in enumerate(li):
print(i)
for index,name in enumerate(li,1):#第二个参数是索引值
print(index,name)
for index, name in enumerate(li, 100): # 起始位置默认是0,可更改
print(index, name)
八字符串str,列表list,元祖tuple和字典dict之间的相互转换
元组转为字典(方式和列表转成字典的方法是一样的)需要通过zip()转换
tup=("a","b","c","d","e")
tup1=(1, 2, 3, 4, 5)
dic=dict(zip(tup,tup1))
print(dic)#{'d': 4, 'e': 5, 'b': 2, 'a': 1, 'c': 3}
列表转换为字典
方法一:使用zip()函数
a = ['a1','a2','a3','a4']
b = ['b1','b2','b3']
d = zip(a,b)
print(dict(d)) # {'a1': 'b1', 'a2': 'b2', 'a3': 'b3'}
将a和b两个列表内的元素两两组合成键值对。
当两个列表的长度不一致时,多出的元素在另一个列表无匹配的元素时就不展示多出的元素。
方法二:使用嵌套列表转换为字典
a = ['a1','a2']
b = ['b1','b2']
c = [a,b]
print(dict(c)) # {'a1': 'a2', 'b1': 'b2'}
# 相当于遍历子列表,如下
dit = {}
for i in c:
dit[i[0]] = i[1]
print(dit)
将列表内的元素自行组合成键值对。
eval() 函数用来执行一个字符串表达式,并返回表达式的值。# Python中常用的数据类型:
-
int:数字:主要用于运算。1 ,2,3…
-
float:浮点
python保留小数位的方法
方法一:format函数 print('{:.3f}'.format(1.23456)) 结果:1.235 print(format(1.23456, '.2f')) 结果:1.23 正如上面代码所示,format有不同用法,前者使用了占位符{},使用占位符可以同时输出多个,后者一次只能输出一个,需要注意的是占位符中的冒号不能丢。笔者推荐使用占位符+format输出。 print('{:.3f} {:.2f}'.format(1.23456, 1.23456)) 结果:1.235 1.23 方法二:'%.xf'方法 print('%.2f' % 1.23456) 结果:1.23 方法三:round()函数 print(round(1.23456,3)) 结果:1.235 print(round(2.355,2)) 结果:2.35 print(round(2.5)) 结果:2 print(round(3.5))
-
str:简单少量的储存数据,并进行相应的操作。name = ‘this is a python’
-
bool:判断真假:True, False.
-
Tuple-元祖:只读,不能更改。(1,‘alex’)****
-
list:大量有序数据,[1,‘ses’,True,[1,2,3],{‘name’:‘jinxin’}]****
-
dict:大量数据,且是关联性比较强的数据{}
-
bytes:bytes类型,是python3.新增加的数据类型
一常见字符串str方法。
1:casefold()将所有的字符转化为小写:
name = "ZhangSan"
print("{0}".format(name.casefold()))
打印结果:zhangsan
2:capitalize()字符串首字母大写其他字符都小写:
name = "zhangSan"
name = name.capitalize()
print("{0}".format(name))
# 打印结果:Zhangsan
3:center()字符串宽度填充:
name = "zhangSan"
name = name.center(12)
print("{0}".format(name))
# 打印结果:' Zhangsan '
# 默认以空格填充
name = "zhangSan"
name = name.center(12, "#")
print("{0}".format(name))
# 打印结果:'##Zhangsan##'
# 以‘#’填充
4:count()统计字符在字符串中出现的次数:
name = "zhangSan"
num = name.count('S')
print("{0}".format(num))
# 打印结果:1
name = "zhangSan"
num = name.count('S', 0, 3) #从0,1,2索引里找
print("{0}".format(num))
#打印结果:0
5:encode()字符串编码:
name = "zhangsan"
name = name.encode('gbk')
print("{0}".format(name))
# 打印结果:b'zhangsan'
6:startswith()判断字符串以某个字符串开头,返回boolean类型:
name = "zhangsan"
isTrue = name.startswith("zh")
print(isTrue)
# 打印结果:True
7:endswith()判断字符串以某个字符串结尾,返回boolean类型:
name = "zhangsan"
isTrue = name.endswith("san")
print(isTrue)
# 打印结果:True
8:find()在字符串中查找指定字符串,找不到时返回-1:
rfind反向查找
name = "zhangsan"
isIn = name.find("an")
print(isIn)
# 打印结果:2
isIn = name.find("an",4)#第二个值为开始的索引值
# 打印结果:6
# 返回字符串开始的下标
9:format()格式化输出字符串:
name = "{} {} zhangsan"
#"{} {}"是占位符,用下边format()里边的参数填充
name = name.format('I', 'am')
print(name)
# 打印结果:I am zhangsan
10:index()在字符串中查找指定的字符串,返回索引找不到时直接报错:
rindex反向查找
name = "zhangsan"
isIn = name.index('a')
print(isIn)
#打印结果:2
11:join()字符串连接:
name = "zhangsan"
name = '*'.join(name)
print(name)
# 打印结果:z*h*a*n*g*s*a*n
12:isalnum()判断字符串是否只包含字母数字:
name = "zhangsan1"
isTrue = name.isalnum()
print(isTrue)
# 打印结果:True
name = "zhangsan1*"
isTrue = name.isalnum()
print(isTrue)
# 打印结果:False
13:isalpha()判断是否只包含字母:
name = "zhangsan"
isTrue = name.isalpha()
print(isTrue)
# 打印结果:True
name = "zhangsan1"
isTrue = name.isalpha()
print(isTrue)
# 打印结果:False
14:isdigit()判断字符串只由数字构成:
name = "1234"
isTrue = name.isdigit()
print(isTrue)
# 打印结果:True
name = "zhangsan1234"
isTrue = name.isdigit()
print(isTrue)
# 打印结果:False
15:isspace()判断字符串是否是空格:
name = " "
isTrue = name.isspace()
print(isTrue)
# 打印结果:True
name = "zhang san"
isTrue = name.isspase()
print(isTrue)
# 打印结果:False
16:isupper()判断字符串是否全是大写字符:
name = "ZHANGSAN"
isTrue = name.isupper()
print(isTrue)
# 打印结果:True
17:lower()将所有的大写字符转为小写字符:
name = "ZHANGSAN"
name = name.lower()
print(name)
# 打印结果:zhangsan
18:lstrip()去除字符串左边的空格:
name = " zhangsan "
name = name.lstrip()
print(name)
# 打印结果:zhangsan
19:rstrip()去除字符串右边的空格:
name = " zhangsan "
name = name.rstrip()
print(name)
# 打印结果: zhangsan
20:strip()去除字符串2边的空格:
name = " zhangsan "
name = name.strip()
print(name)
# 打印结果:zhangsan
21:replace()字符串替换:
name = "zhangsan"
name = name.replace("zhang", "li")
print(name)
# 打印结果:lisan
22:split()字符串分割,默认是空格:
name = "zhang san"
name = name.split()
print(name)
# 打印结果:['zhang', 'san']
23:add()在字符串后边添加字符串:
name = "zhang"
name = name.__add__("san")
print(name)
# 打印结果:zhangsan
24:contains()判断指定字符串是否包含在字符串中:
name = "zhangsan"
isTrue = name.__contains__("san")
print(isTrue)
# 打印结果:True
25:eq()判断字符串是否相等:
name = "zhangsan"
name1 = "zhangsan"
isEq = name.__eq__(name1)
print(isEq)
# 打印结果:True
二读取字符串中的某些字符
s = “Hello, my name is Alex,golden king.”
字符串特性:
1 按照从左到右的顺序定义字符集合,下标从0开始顺序访问,有序
2 不可变,字符串是不可变的,不能像列表⼀样修改其中某个元素,所有对字符串的修改操作其实都是相当于生成了⼀份新数据。
3 可进行切片操作
切片:就是通过索引(索引:索引:步长)截取字符串的一段,形成新的字符串(原则就是顾头不顾尾)。
s = 'abcdefghigklmn'
print(s[0:3]) #abc
print(s[2:5]) #cde
print(s[0:]) #默认到最后
print(a[0:len(a)])
print(s[0:-1]) # -1 是列表中最后一个元素的索引,但是要满足顾头不顾腚的原则,所以取不到K元素
print(s[0:5:2]) #加步长 ace
print(s[5:0:-2]) #反向加步长
print(s[::2])#返回acegikm
三元祖类型 tuple
定义元组:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改
如果要定义一个空的tuple,可以写成()
:
但是,要定义一个只有1个元素的tuple,如果你这么定义: t = (1),定义的不是tuple,是1
这个数!这是因为括号()
既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1
。
所以,只有1个元素的tuple定义时必须加一个逗号,
,来消除歧义:
t = (1,)
创建元组:
tup = (11, 22, 33, 44, 55)
或
tup = tuple((11, 22, 33, 44, 55))
基本操作:索引,切片,循环,长度,包含
基本函数:
cmp(tuple1,tuple2):比较两个元组元素
len(tuple)计算元组元素个数
max(tuple)返回元组中元素最大值
min(tuple)返回元组中元素最小值
tuple(seq)将列表转换为元组
四列表list
列表是python中的基础数据类型之一,其他语言中也有类似于列表的数据类型,比如js中叫数组,他是以[]括起来,每个元素以逗号隔开,而且他里面可以存放各种数据类型
常用方法
方法 | 意义 |
---|---|
L.index(val, start,end) | 返回对应元素的索引下标, begin为开始索引,end为结束索引,当 value 不存在时触发ValueError错误 |
L.insert(index, obj) | 将某个元素插放到列表中指定的位置,其中,index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。 |
L.count(x) | 返回列表中元素的个数 |
L.remove(x) | 从列表中删除第一次出现在列表中的值 |
L.copy() | 复制此列表(只复制一层,不会复制深层对象),此层发生改变,复制曾也会受到影响 |
L.append(x) | 向列表尾部追加单个元素,当给 append() 方法传递列表或者元组时,会将它们视为一个整体,作为一个元素添加到列表中,从而形成包含列表和元组的新列表。 |
L.extend(lst) | 向列表追加另一个列表,不会把列表或者元祖视为一个整体,而是把它们包含的元素逐个添加到列表中。 |
L.clear() | 清空列表,等同于 L[:] = [] |
L.sort(reverse=False) | 将列表中的元素进行排序,默认顺序按值的小到大的顺序排列 |
L.reverse() | 列表的反转,用来改变原列表的先后顺序 |
L.pop([index]) | 删除索引对应的元素,如果不加索引,默认删除最后元素,有返回值 |
del L[start,end] | 按照索引去删除,也可切片删除没有返回值 |
一,改变list中的值利用索引既可以改变:
L[2]="我是新数据"
二,按切片去改实质是按迭代增加到列表
L [1:4] = ['a','b'] #索引1-3的值改为a,b
已知列表 li=[("s",12),("b",23)]
6.1 按照第二个元素进行从大到小的排序
li.sort(key=lambda x:x[1],reverse=True)
数据转成字典
dict(li)
列表生成式
list = [i for i in range(9)]
print(list)#012345678
五字典dict
字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据。python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的,且key必须是可哈希的。可哈希表示key必须是不可变类型,如:数字、字符串、元组。
创建字典的方法
创建一个空字典 这是最常用的
dict={}
传入可迭代对象
b = dict(zip(['one','two','three'],[1,2,3]))
print(b) #{'one': 1, 'two': 2, 'three': 3}
listRet=list(zip(['one','two','three'],[1,2,3]))
print(listRet) #[('one', 1), ('two', 2), ('three', 3)]
c = dict([('one', 1), ('two', 2), ('three', 3)])
print(c) #{'one': 1, 'two': 2, 'three': 3}
c1 = dict([('one', 1), ('two', 2), ('three', 3),('three', 4),('three', 5)])
print(c1) #如果键有重复,其值为最后重复项的值。
#传入映射对象,字典创建字典
d = dict({'one': 1, 'two': 2, 'three': 3})
print(d)
对字典操作的方法:
增:
第一种:
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic['address'] = "海南"
dic["address1"] = "云南"
print(dic)
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic['li'] = ["a","b","c"]
print(dic)
第二种:
#setdefault()方法: 在字典中添加键值对,如果只有键那对应的值是none,但是如果原字典中存在设置的键值对,则他不会更改或者覆盖。
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic.setdefault('k','v')
print(dic) # {'age': 18, 'name': 'tan', 'sex': 'girle', 'k': 'v'}
dic.setdefault('k','v1')# {'age': 18, 'name': 'tan', 'sex': 'girle', 'k': 'v'}
print(dic)
setdefault() 方法:
setdefault() 方法用来返回某个 key 对应的 value,其语法格式如下:
dictname.setdefault(key, defaultvalue)
说明,dictname 表示字典名称,key 表示键,defaultvalue 表示默认值(可以不写,不写的话是 None)。
当指定的 key 不存在时,setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue,然后再返回 defaultvalue。
也就是说,setdefault() 方法总能返回指定 key 对应的 value:
- 如果该 key 存在,那么直接返回该 key 对应的 value;
- 如果该 key 不存在,那么先为该 key 设置默认的 defaultvalue,然后再返回该 key 对应的 defaultvalue。
删:
第一种:pop()方法:根据key删除键值对,并返回对应的值,如果没有key则返回默认返回值
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic_pop = dic.pop("tan",'无key默认返回值')
print(dic_pop)
del 除键值对 没有返回值
del dic["name"] # 没有返回值。
print(dic)
第二种:
dic_clear = dic.clear() # 清空字典
print(dic,dic_clear) # {} None
popitem():用来随机删除一个键值对
dic={'age': 18, 'name': 'tan', 'sex': 'girle'}
dic.popitem()
改:
第一种:通过键去改
dic = {"name":"tom","age":18,"sex":"male"}
dic["name"]="jom"
print(dic)
第二种:update()方法:将所有的键值对覆盖添加(相同覆盖,没有的添加)
dic = {"name":"tom","age":18,"sex":"male"}
dic2 = {"name":"wu","weight":75}
dic2.update(dic) # 将dic所有的键值对覆盖添加(相同的覆盖,没有的添加)到dic2中
print(dic2)#{'name': 'tom', 'weight': 75, 'age': 18, 'sex': 'male'}
查:
第一种:通过键名查
value1 = dic["name"] # 没有会报错
print(value1)
第二种:通过get()方法去查
value2 = dic.get("key","默认返回值") # 没有可以返回设定的返回值默认defalut=none
print(value2)
其他操作:
items()方法是可迭代的,返回列表,含所有(键,值)元组的列表
keys()方法:得到字典的键,返回列表,可迭代
values()方法:得到字典的值,返回列表 ,可迭代
'key' in dic #若存在则返回True,没有则返回False
dic.keys() #返回⼀个包含字典所有KEY的列表;
dic.values() #返回⼀个包含字典所有value的列表;
dic.items() #返回⼀个包含所有(键,值)元组的列表;
遍历
1、for k in dic.keys():
2、for k,v in dic.items() :
3、for k in dic :# 推荐⽤这种,效率速度最快
info = {
"name":"张勇峰",
"mission": "加油加油",
"website": "www"
}
for k in info:
print(k,info[k])
六set集合
定义:集合是无序的,不重复的数据集合。以下是集合最重要的两点:去重,把一个列表变成集合,就自动去重了。
特性:因为集合中的元素是不可重复的,且无序的,所以不支持索引,切片,连接。集合只支持成员操作符 迭代(for循环)
集合的创建
第一:set({})方法:创建集合
set1 = set({1,2,'marry'})
第二:{}
set2 = {1,2,'marry'}
增
add()
update()方法:迭代着增加
删除
remove()方法:删除一个元素
pop()方法:随机删除一个元素
clear()方法: 清空集合
del属性: 删除集合
交集intersection()
s1 = {1,2,3}
s2 = {2,3,4}
#交集
print('交集: ',s1.intersection(s2))
print('交集: ',s1 & s2)
并集union()
s1 = {1,2,3}
s2 = {2,3,4}
#并集
print('并集: ',s1.union(s2))
print('并集: ',s1 | s2)
差集difference()
s1 = {1,2,3}
s2 = {2,3,4}
print('差集: ',s1.difference(s2)) #s1 - (s1&s2)
print('差集: ',s2.difference(s1)) #s2 - (s1&s2)
对等差分symmetric_difference()
s1 = {1,2,3}
s2 = {2,3,4}
print('对等差分: ',s1.symmetric_difference(s2))
print('对等差分: ',s2^s1)
子集issuperset()
s1 = {1,2}
s2 = {1,2,3}
print(s1.issuperset(s2))
print(s1.issubset(s2))
判断两个集合是否相交isdisjoint
s1 = {1,2}
s2 = {1,2,3}
print(s1.isdisjoint(s2))
七enumerate枚举是同时获得索引和值
enumerate:枚举,对于一个可迭代的(iterable)/可遍历的对象(如列表、字符串),enumerate将其组成一个索引序列,利用它可以同时获得索引和值。
li = ['marry','男神','女神','tim','吴东坡']
for i in enumerate(li):
print(i)
for index,name in enumerate(li,1):#第二个参数是索引值
print(index,name)
for index, name in enumerate(li, 100): # 起始位置默认是0,可更改
print(index, name)
八字符串str,列表list,元祖tuple和字典dict之间的相互转换
元组转为字典(方式和列表转成字典的方法是一样的)需要通过zip()转换
tup=("a","b","c","d","e")
tup1=(1, 2, 3, 4, 5)
dic=dict(zip(tup,tup1))
print(dic)#{'d': 4, 'e': 5, 'b': 2, 'a': 1, 'c': 3}
列表转换为字典
方法一:使用zip()函数
a = ['a1','a2','a3','a4']
b = ['b1','b2','b3']
d = zip(a,b)
print(dict(d)) # {'a1': 'b1', 'a2': 'b2', 'a3': 'b3'}
将a和b两个列表内的元素两两组合成键值对。
当两个列表的长度不一致时,多出的元素在另一个列表无匹配的元素时就不展示多出的元素。
方法二:使用嵌套列表转换为字典
a = ['a1','a2']
b = ['b1','b2']
c = [a,b]
print(dict(c)) # {'a1': 'a2', 'b1': 'b2'}
# 相当于遍历子列表,如下
dit = {}
for i in c:
dit[i[0]] = i[1]
print(dit)
将列表内的元素自行组合成键值对。
eval() 函数用来执行一个字符串表达式,并返回表达式的值。
标签:常用,name,isTrue,Python,数据类型,dic,字符串,print,列表 来源: https://blog.csdn.net/apple_50618492/article/details/114677666