Python基础之数据类型

时间:2022-10-19 17:59:45

一、字符串

  定义:它是一个有序的字符的集合,用于存储和表示基本的文本信息,' '或" "中间包含的内容称之为字符串
  特性:
    1.只能存放一个值
    2.不可变
    3.按照从左到右的顺序定义字符集合,下标从0开始顺序访问,有序
  补充:
    1.字符串的单引号和双引号都无法取消特殊字符的含义,如果想让引号内所有字符均取消特殊意义,在引号前面加r,如name=r'l\thf'
    2.unicode字符串与r连用必需在r前面,如name=ur'l\thf'

  字符串的创建:

  "hello world"

  字符串常用操作:

    1、移除空白:

name = "    michael,egon,jack"
print(name.strip()) #去掉行头和尾部的空格
"michael,egon,jack" #输出结果

    2、分割:

name = "michael,egon,jack"
print(name.split(",")) #分割,以","为分隔符把一个字符串分割成列表
['michael', 'egon', 'jack'] #输出结果

    3、长度:

name = "michael,egon,jack"
print(len(name)) #统计字符串的长度
17 #输出结果

    4、索引:

name = "michael,egon,jack"
print(name.index("a")) #索引
4 #输出结果,找到第一个对应的值的下标返回值

    5、切片:

name = "michael,egon,jack"
print(name[0:7]) #取出第一个名字,就是在[]里以":"分割左右分别写出元素对应的下标,默认从左往右取。记住“顾头不顾尾”
michael #输出结果
print(name[8:12]) #取出第二个名字
egon #输出结果
print(name[-4:]) #取出最后一个名字,从后面往前面数元素的下标,有几个元素,就写-(几个) 注意:要记住“顾头不顾尾”
jack #输出结果

    6、步长:

  string[start:end:step]的序列切片中,第一个“:”隔离了 起始索引 和 结束索引,第二个“:”隔离了 结束索引 和 步长

  • step为正,则从左到右切片,如果start > end,则为空
  • step为负,则从右到左切片,如果start < end,则为空
  • start和end非同时为空,前者表示最开始的一个位,后者表示一直到最后一个,同时为空的时候,表示取所有。至于方向,还是取决于step的值。

  可以总结一句规律:step为正表示从左到右切片,反之为从右到左,然后根据index依次切片。

name = "michael,egon,jack"
print(name[::3]) #取所有,step为3
mhlg,c #输出结果
print(name[12:3:-3]) #取索引3---12的元素,从右到左切片step为3 注意:记住“顾头不顾尾”
,gl #输出结果

 二、列表

  定义:[]内以逗号分隔,按照索引,存放各种数据类型,每个位置代表一个元素
  特性:
    1.可存放多个值
    2.可修改指定索引位置对应的值,可变
    3.
按照从左到右的顺序定义列表元素,下标从0开始顺序访问,有序

  列表的创建:

list_test=[’afg‘,12,'ok']

list_test=list('abc')

list_test=list([’afg‘,12,'ok'])  

  列表的常用操作:

  1、索引:

names = ["michael","egon","jack","alex","tom"]
print(names.index("jack")) #检索“jack”的下标值
2 #输出结果

  2、切片:

names = ["michael","egon","jack","alex","tom"]
print(names[0:4])#通过下标找出列表中的元素0---3给切出来
['michael', 'egon', 'jack', 'alex'] #输出结果

  3、追加:

names = ["michael","egon","jack","alex","tom"]
names.append("rose") #追加内容
print(names) #输出列表names
['michael', 'egon', 'jack', 'alex', 'tom', 'rose'] #输出结果,最后一个位追加的内容

  还有一种追加的方式:insert() 函数用于将指定对象插入列表的指定位置。

  注意:该方法没有返回值,但会在列表指定位置插入对象。

names = ["michael","egon","jack","alex","tom"]
names.insert(2,"jerry") #可以在指定位置添加元素,因为没有返回值,所以此时不用打印输出
print(names) #打印输出结果
['michael', 'egon', 'jerry', 'alex', 'jack', 'tom'] #输出结果

  4、删除:

  第一种方法:pop() 函数用于移除列表中的一个元素(默认最后一个元素),并且返回该元素的值。

names = ["michael","egon","jack","alex","tom"]
print(names.pop(3)) #删除,指定删除下标位为3的元素
alex #输出结果
print(names.pop()) #默认删除最后一个
tom #输出结果

  第二种方法:remove() 函数用于移除列表中某个值的第一个匹配项。该方法没有返回值但是会移除两种中的某个值的第一个匹配项。

names = ["michael","egon","jack","alex","tom","egon"]
print(names.remove("egon")) #删除egon,匹配列表中第一个对应的元素,后面的不会影响
None #输出结果
print(names.remove("rose")) #删除rose,因为列表没有这个元素,so,会报错“rose”没在列表中
print(names) #输出删除后的names的值
['michael', 'jack', 'alex', 'tom', 'egon'] #输出的结果

  第三种方法:使用 del 语句来删除列表的的元素。

names = ["michael","egon","jack","alex","tom",'egon']
del names[3:5] #实际删除下标位3到5的元素,注意:最后一个5删不了,记住“顾头不顾尾”
['michael', 'egon', 'jack', 'egon'] #输出结果
del names[-3:] #删除倒数第三至最后一个
['michael', 'egon', 'jack'] #输出结果

  还有一种 clear() 函数用于清空列表,该方法没有返回值,类似于del list[:]。

names = ["michael","egon","alex","jack","tom"]
names.clear() #清空列表names
print("清空后的列表:",names) #输出打印结果
清空后的列表: [] #注意:此时列表names里的元素被清空了,但是列表names还是存在的

  5、长度:

  len() 方法返回列表元素个数。

names = ["michael","egon","jack","alex","tom"]
print(len(names)) #统计列表的元素个数
5 #输出结果

  6、循环:  

  第一种:这个迭代names,并且每次迭代取names的值到 i 这个变量里。

names = ["michael","egon","jack","alex","tom"]
for i in names:
print(i)
michael #以下这几个都是列表里的值
egon
jack
alex
tom

  第二种:这个也是类似,只是每次迭代取索引的值到 i 这个变量里。

names = ["michael","egon","jack","alex","tom"]
for i in range(len(names)):
print(i,names[i])
0 michael
1 egon
2 jack
3 alex
4 tom

  总结:这两种用起来区别不大,用第一个的话是用不到索引的时候用,后面这个是用到索引的时候用,其他的实际用那个看个人需求了。

  7、包含:在python中可以通过in和not in关键字来判读一个list中是否包含一个元素。

names = ["michael","egon","jack","alex","tom"]
if "michael" in names: #判断“michael”是否在names列表里
print("%s in the names"%("michael")) #在的话,打印输出结果
if "rose" not in names: #判断“rose”是否在names列表里
print("%s is not in the names"%("rose")) #不在的话,打印输出结果
michael in the names #输出结果
rose is not in the names #输出结果

三、元组 

  定义:与列表类似,只不过[]改成()。

  特性:

    1、可存放多个值

    2、不可变

    3、按照从左到右的顺序定义元组元素,下标从0开始顺序访问,有序

   元组的创建: (注意:元组中只包含一个元素时,需要在元素后面添加逗号

ages = (11, 22, 33, 44, 55)

ages = tuple((11, 22, 33, 44, 55))
print(ages)
(11, 22, 33, 44, 55) #输出结果
a = (11,) #只有一个元素的时候,后面要加“,”标识
print(a)
(11,) #输出结果

  元组常用操作:

  1、索引:

ages = (11,22,33,"a","b","c")
print(ages.index("a")) #索引"a"元素的下标
3 #输出结果

  2、切片:

ages = (11,22,33,"a","b","c") #注意:在取值的时候一定要记住“顾头不顾尾”
print(ages[:3]) #取元组的最开始到下标索引为2的元素
(11, 22, 33) #输出结果
print(ages[2:4]) #取下标索引为2到3的元素
(33, 'a') #输出结果
print(ages[-3:]) #取元组的后三个元素
('a', 'b', 'c') #输出结果
print(ages[-3:-1]) #取从元组的倒数第三个元素开始取到倒数第一个(不包含最后一个)
('a', 'b') #输出结果

  3、循环:

  同上列表的循环

  4、长度

  len() 方法返回元组元素个数。

ages = (11,22,33,"a","b","c")
print(len(ages)) #统计元组元素的个数
6 #输出结果

  5、包含:(同列表一样)

ages = (11,22,33,"a","b","c")
if 22 in ages: #判断22是否在names列表里
print("%s in the ages"%(22)) #在的话,打印输出结果
if "e" not in ages: #判断“e”是否在names列表里
print("%s is not in the names"%("e")) #不在的话,打印输出结果
22 in the ages #输出结果
e is not in the names #输出结果

  6、删除:

ages = (11,22,33,"a","b","c")
del ages #删除元组
print(ages) #打印输出元组
NameError: name 'ages' is not defined #输出报错,此元组不存在

四、字典

  定义:字典是另一种可变容器模型,且可存储任意类型对象。键必须是唯一的,但值则不必。值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。

    {key1:value1,key2:value2},key-value结构,key必须可hash

  特性:

    1.可存放多个值

    2.可修改指定key对应的值,可变

    3.无序

  字典的创建:

person = {"name": "michael", 'age': 18}
person = dict(name='michael', age=18)
person = dict({"name": "michael", 'age': 18})
person = dict((['name','michael'],['age',18]))
{}.fromkeys(seq,100) #不指定100默认为None

  注意:

dic = {}.fromkeys(["k1","k2"],11) #创建字典dic
{'k1': 11, 'k2': 11} #输出结果

   字典的常用操作: 

  • len(d)返回d中项(键-值对)的数量;
  • d[k]返回关联到k上的值;
  • d[k]=v将值v关联到键k上;
  • del d[k]删除键为k的项;
  • k in d检查d中是否有含键为k的项。

 

  1、clear

  clear方法清除字典中所有的项,这是个原地操作,无返回值(或者说返回none)。

dic = {"k1":"v1","k2":"v2","k3":"v3"}
dic.clear() #清空字典
print(dic) #打印输出
{} #输出结果

  2、cope

  copy方法返回一个具有相同键-值对的新字典(这个方法实现的是浅复制,因为值本身是相同的,而不是副本)

  在副本中替换值时,原始字典不受影响,但是如果修改了某个值,原始字典会改变。

>>> x = {'a':1,'b':[2,3,4]}
>>> y = x.copy()
>>> y['a'] = 5 #替换key对应value值
>>> y['b'].remove(3) #修改了“b”对应的value值
>>> y
{'a':5,'b':[2,4]} #被修改的字典
>>> x
{'a':1,'b':[2,4]} #原字典输出的结果,替换的值没变,修改的变了

  避免这个问题的方法是使用深度复制-deepcopy(),复制其包含所有的值。

>>> x = {'a':1,'b':[2,3,4]}
>>> y = x.copy()
>>> z = x.deepcopy() #x深cope成z
>>> x['a'].append(5) #对原文件进行操作
>>> y
{'a':1,5,'b':[2,3.4]} #浅cope的值发生了改变
>>> z
{'a':1,'b':[2,3,4]} #深cope的值没有发生改变

  3、get:

  get方法是个更宽松的访问字典项的方法。当使用get访问一个不存在的键时,会得到None值。还可以自定义“默认”值,替换None。

>>> d = {}
>>> print d.get('name') #默认为None
None
>>> d.get("name",'N/A') #自定义为'N/A'
'N/A'
>>> d[''name] = 'Eric' #给字典d赋值
>>> d.get('name') #当键存在,输出键对应的值
'Eric' #输出结果

  4、has_key

  has_key方法可以检查字典中是否含有给出的键。d.has_key(k)

>>> d = {}
>>> d.has_key('name')
False

  5、items和iteritems

  items方法将所有的字典项以列表方式返回,但是列表中的每一项(键,值)返回时并没有特殊的顺序。

  iteritems方法的作用大致相同,但是会返回一个迭代器对象而不是列表:

>>> d = {'a':1,'b':2,'c':3}
>>>d.items
[('a',1),('b',2),('c',3)]
>>> it = d.iteritems()
>>> it
<dictionary-iteritems object at 169050>
>>> list(it)
[('a',1),('b',2),('c',3)]

  6、pop

  pop方法用来获得对应给定键的值,然后将这个键-值对从字典中移除。

>>> d = {'a':1,'b':2,'c':3}
>>> d.pop('a') #删除a及对应的值
>>> d
{'b':2,'c':3} #输出结果

  7、popitem

  popitem方法会弹出随机项,并没有顺序的概念。若想一个接一个地移除并处理项,这个方法就非常有效了。

>>> d = {'a':1,'b':2,'c':3}
>>> d.popitem() #随机删除一个键、值
>>> d
{'a':1,'c':3} #输出结果

  8、setdefault

  setdefault方法在某种程度上类似于get方法,就是能够获得与给定键相关联的值,还能在字典中不含有给定键的情况下设定相应的键值。

>>> d = {}
>>> d.setdefault('name','N/A')
'N/A'
>>> d
{'name': 'N/A'}
>>> d.setdefault('name',A)
'N/A'

  9、update

  update方法可以利用一个字典项更新另一个字典。提供的字典项会被添加到旧的字典中,若有相同的键则会进行覆盖。

>>> d = {'a':1,'b':2,'c':3}
>>> x = {'a':5,'d':6}
>>> d.update(x)
>>> d
{'a': 5, 'c': 3, 'b': 2, 'd': 6} #遇到相同的键会覆盖对应的value的值

  10、values

  values方法以列表的形式返回字典中的值(itervalues返回值的迭代器),与返回键的列表不同的是,返回值列表中可以包含重复的元素。

>>> d = {}
>>> d[1]=1
>>> d[2]=2
>>> d[3]=3
>>> d[4]=1
>>> d
{1: 1, 2: 2, 3: 3, 4: 1}
>>> d.values()
[1, 2, 3, 1] #值可以重复

  五、集合

  定义:由不同元素组成的集合,集合中是一组无序排列的可hash值,可以作为字典的key

  基本功能:是进行成员关系测试和删除重复元素。

  特性:集合的目的是将不同的值存放到一起,不同的集合间用来做关系运算,无需纠结于集合中单个值

  可以使用大括号({})或者 set()函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。

  集合分类:可变集合、不可变集合

    可变集合(set):可添加和删除元素,非可哈希的,不能用作字典的键,也不能做其他集合的元素

    不可变集合(frozenset):与上面恰恰相反

  集合的创建:

  由于集合没有自己的语法格式,只能通过集合的工厂方法set()和frozenset()创建

{1,2,3,1}

定义可变集合set
>>> set_test=set('hello')
>>> set_test
{'l', 'o', 'e', 'h'}
改为不可变集合frozenset
>>> f_set_test=frozenset(set_test)
>>> f_set_test
frozenset({'l', 'e', 'h', 'o'}) 

  访问集合:

  由于集合本身是无序的,所以不能为集合创建索引或切片操作,只能循环遍历或使用in、not in来访问或判断集合元素。

student = ({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'})
print("Tom" in student) #判断“Tom”是否在集合student中
True #真,在集合student里
print("Egon" in student) #判断“Egon”是否在集合student中
False #假,不在集合student里
for i in student: #循环输出集合student中的所有元素
print(i) #以下是输出结果
Mary
Jim
Tom
Jack
Rose

  集合常用操作:关系运算

  1、in 和 not in:

student = ({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'})
print(student) # 输出集合,重复的元素被自动去掉
{'Mary', 'Rose', 'Tom', 'Jim', 'Jack'} #输出结果
# 成员测试
if('Rose' in student) :
print('Rose 在集合中')
else :
print('Rose 不在集合中')

  2、等于(==)和不等于(!=):

a = {1,2,3}
b = {1,2,3,4,5}
print(a == b)
False
print(a != b)
True

  3、大于(>)与小于(<)和大于等于(>=)于小于等于(<=):注意:小于(用函数表示 .issubset()) 大于(用函数表示 .issuperset())

a = {1,2,3}
b = {1,2,3,4,5}
print(a <= b) #判断a小于或等于b
True
print(a < b) #判断a小于b
print(a.issubset(b)) #a是b的子集
print(b.issuperset(a)) #b是a的超集True
print(a >= b) #判断a大于或等于b
False
print(a > b) #判断a大于b
False

  4、交集:intersection(),简写符(&)

a = {1,2,3}
b = {1,2,3,4,5}
print(a.intersection(b)) #交集
print(a & b) #交集的简写
{1, 2, 3} #输出a与b的交集

  5、并集:union(),简写符( | )

a = {1,2,3}
b = {1,2,3,4,5}
print(a.union(b)) #并集 两个合在一起
print(a | b) #并集的简写
{1, 2, 3, 4, 5} #输出a与b的并集

  6、差集:difference(),简写符(-)

a = {1,2,3}
b = {1,2,3,4,5}
print(a.difference(b)) #差集 a相对于b不一样的打印出a有b没有的
print(a - b) #差集的简写
set() #因为a不包含b,so,为空
print(b.difference(a)) #差集 b相对于a不一样的打印出b有a没有的
print(b - a) #差集的简写
{4, 5} #打印出相差的部分

  7、对称差分:symmetric_difference(),简写符(^)

a = {1,2,3,6,7}
b = {1,2,3,4,5}
print(a.symmetric_difference(b)) #对称差分 把a和b中不在的都打印出来
print(a ^ b) #对称差分的简写
{4, 5, 6, 7} #输出结果

  注意:集合之间and,or

a = {1,2,3,6,7}
b = {1,2,3,4,5}
print(a and b) #取b的值
{1, 2, 3, 4, 5}
print(a or b) #取a的值
{1, 2, 3, 6, 7}

  8、子集和超集: .issubset()  和  .issuperset()

a = {1,2,3}
b = {1,2,3,4,5}
print(a.issubset(b)) #a是b的子集 ,是真为True,反之亦然。
True
print(a.issuperset(b)) #b是a的超集, 是假为False,反之亦然。
False

  集合更新:

  可使用以下内建方法来更新:注意:只有可变集合才能更新。

  • a.add()
  • a.update()
  • a.remove()
  • a.discard()
  • a.pop()
a = {1,2,3,6,7}
a.add(8) #在集合a里添加一个元素“8”
print(a) #打印输出
{1, 2, 3, 6, 7, 8} #输出结果

a = {1,2,3,6,7}
c = {6,,7,8,9}
a.update(c) #更新a集合,将c集合的元素添加到a中,注意:集合是天然去重的。
print(a)
{1, 2, 3, 6, 7, 8, 9}

a = {1,2,3,6,7}
a.remove(6) #移除集合a中的元素“6”,如果被移除的元素不存在时,会报错。
print(a)
{1, 2, 3, 7}

a = {1,2,3,6,7}
a.discard(9) #删除指定元素,但是如果要删除的不在集合里不会报错。
print(a)
{1, 2, 3, 7}

a = {1,2,3,6,7}
print(a.pop()) #随机删除
1 #随机删除的结果