Python编程中的数据结构

3.1  Python中的索引和切片

3.1.1  Python中的索引

◆索引：我们可以直接使用索引来访问序列中的元素，同时索引可分为正向和负向两种，而切片也会用到索引。支持字符串(String)、列表(List)、元组(Tuple)【不可变】，但不支持集合和字典【可变】。

◆序列:包括字符串(String)、列表(List)、元组(Tuple)、集合和字典。

下面放上一个图，有助于大家理解正、负向索引的区别，如图所示：

Ø正向索引取值，例：

str='python'  print(str[0])#输出p   print(str[3])#输出h

print(str[6])#报错，索引越界string index out of range

Ø负向索引取值，例：

str='python'  print(str[-1])#输出n

3.1.2  Python中的切片

◆切片：指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

◆切片的语法：[start_index : end_index : step]

Østart_index表示起始索引,即索引开始的位置     

Øend_index表示结束索引，即结束索引的步长。

Østep表示步长，即表示选取间隔。步长不能为0，且默认值为1

★注意：切片操作是指按照步长，截取从起始索引到结束索引，但不包含结束索引(也就是结束索引减1)的所有元素。

Python中的切片实例 :   str='python'  

Øprint(str[0:3])#从索引0开始到第三位结束,不包含第三位,即0,1,2位      print(str[1:3])       print(str[2:-1])

Øprint (str[:-1])#不设起始索引,默认从0位开始   

★切片反转：str='python'   print(str[::-1])#输出nohtyp

Øprint (str[2:])#不设结束索引,默认取到末尾   

Øprint (str[1:6:3]）#输出yo

Øprint(str[-1:-5]）#步长为正则从左往右取值，结果为空

print(str[-5:-1]）#输出ytho   

Øprint(str[-1:-5:-1])#从右往左确定数位,步长为负则从右往左取值#输出noht

Øprint(str[2::-1]）#输出typ  print(str[:2:-1]）#noh    

Øprint(str[::-1])#输出nohtyp   print(str[::1])#输出python

print(str[::-2])#输出结果为nhy

print(str[::2])#输出结果为pto

反转输出面试题常遇: 

print(str[-2:-5:-1])#输出结果为oht

print(str[-5:-1:-1]）#输出结果为空

3.2  Python中的字符串

3.2.1  字符串

Ø字符:指类字形单位或符号，包括字母、数字、运算符号、标点符号和功能性符号以及其它字符，通常由8个二进制位(一个字节)表示一个字符。

Ø字符串：常用‘str’表示，由一连串字符组成。是Python中最常用的数据类型，用单引号''或者双引号""来创建字符串。

例：str1 = 'hello Kitty'     str2 = "hello Kitty"

3.2.2  字符串常用函数

字符串常用函数定义：表示每个输入值对应唯一输出值的一种对应关系。

◆Øcapitalize()：使字符串首字母大写

str1='hello_are_you_ok'    print (str.capitalize())

Øtitle():使字符串首字母大写

str1='hello_are_you_ok'      print(str1.title())

★区别:capitalize只有整个字符串的第一个字母大写,title作用于整个字符串内的单词的首字母大写。

◆lower()：将字符串中所有字母转换为小写字母输出

str='ADFASDF'  print (str.lower())#输出adfasdf

◆upper()：将字符串中的所有字符转换为大写字母输出

str='AsWRsdfsdfDSF'  print (str.upper())#输出ASWRSDFSDFDSF

◆count()：统计具体字符出现的次数

str = 'abcad'       print (str.count('a'))

◆join()：把集合中的字符按自定义的分隔符连接在一起

     str ="abcad"        print ('-'.join(str))#输出a-b-c-a-d

◆split()：把字符串通过指定的标识符进行分割

    str ="abcad"   print (str.split('b'))#指定分隔符存在时，去掉分隔符，剩下元素保留并转化为一个列表。如['a', 'cad']

print (str.split('*'))#指定分隔符不存在时，所有元素转化成一个列表。如：['abcad']

Ø例：把hello_python转化为HelloPython.

方法1：str='helo_python'       方法2:s='helo_python'
st=str.title()               s1=s.title().split('_')
s=st.split('_')              print(s1[0]+s1[1])
print(s[0]+s[1])

#输出HeloPython

◆strip(ab)：删除字符串开头和结尾有a或b的字符

str ="abcad"  print (str.strip('ab'))#输出cad

str ="abcad"  print (str.strip('ac'))#输出bcad

str ="abcad"  print (str.strip('ad'))#输出bc

◆lstrip(ab)：删除字符串开头有ab序列字符

str ="abcad"  print (str.lstrip('a'))

#输出bcad

◆rstrip(ab)：删除字符串结尾有ab序列字符

Østr ="abcad"  print (str.rstrip('d'))#输出abca

Øs="abc_abc_abc_abc"print(s.lstrip('ac'))#bc_abc_abc_abc

Øprint(s.rstrip('acb'))#输出abc_abc_abc_

◆startswith()：判断字符串是否以什么开始

str ="abcad"  print (str.startswith('a'))

#这里输出结果为true或false

◆endswith()：判断字符串是否以什么结束

Østr ="abcad"     print (str.endswith('d'))

#这里输出结果为true或false

Ø例：nasa=input('请上传正确的文件：')
if nasa.endswith('.txt'):
    print('上传成功')
else:
    print('上传失败')

◆find()/rfind()：字符串查询find()是从左边开始查，rfind()是从右边开始查，确定元素后，最终下标结果依据正向索引显示

python 编程基础课程https://edu.csdn.net/course/detail/36170

str1 ="duoguladuo.test"    print (str1.find("o"))#输出2
print (str1.rfind("o"))#输出9 print (str1.rfind("l"))#输出5

◆replace()：replace(substring,newstring,max) substring表示被替换的字符串,newstring要替换字符串,max表示替换的次数

str2='duoguladuo.test'   Øprint(str2.replace('g','t'))#duotuladuo.test

Øprint(str2.replace('g','t',2))#duotuladuo.test#替换两个前往后
Øprint(str2.replace('o','s'))#替换次数不填，默认替换全部#dusguladus.test
Øprint(str2.replace('o','s',1))#dusguladuo.test

◆isdigit()：判断字符串中是否全为数字

str='abcd'     print (str.isdigit())

◆isalpha()：判断字符串中是否全为字母

str='abcd'      print (str.isalpha())

◆isalnum()：判断字符串当中是否全都为数字，全为字母，或者数字字母组合。返回布尔值：True和False 如果有特殊符号就是否

str='1234aa@#$'     print (str.isalnum())

◆istitle()：判断字符串中首字母是否为大写，其他是否为小写，其他不为小写则为否

Østr='PyThon'    print(str.istitle())#输出False

Østr='Python'    print(str.istitle())#输出True

◆isupper()/islower():is开头的就是判断一个字符串是否展示为都是大写或者都是小写

Østr.isupper() 是否全大写      Østr.islower()是否全小写

3.3  Python中的列表

3.3.1  Python中的列表定义

◆列表(list):是一组有序存储的数据，也是python常见的序列之一，序列中的每个元素都分配一个索引，第一个元素索引是0，第二个元素索引是1，依此类推。序列都可以进行的操作包括索引，切片，加，乘，检查成员。

◆列表表达符号：[]          查看列表类型：print(type(表名))

◆定义列表的方法：

Ø方法一：list1 = [1,2,3,4] #直接通过[]进行定义

Ø方法二：list2 = list('1234') #使用list()方法进行定义

3.3.2  列表中对应的函数

◆索引和切片赋值

list1 = [1,88,'test','duoceshi']    list1[0] = 666

list1[2:] = list('123')

Ø例(索引赋值)：str='password'  dj=list(str)  dj[0]='PW'   print(dj)#输出['PW', 'a', 's', 's', 'w', 'o', 'r', 'd']

Ø例(切片赋值)：dj=['PW', 'a', 's', 's', 'w', 'o', 'r', 'd']
dj[0:1]='MN'     print(dj)

#输出['M', 'N', 'a', 's', 's', 'w', 'o', 'r', 'd']

Ødj=['PW', 'a', 's', 's', 'w', 'o', 'r', 'd']  dj[2:]=list('MN')（或dj[2:]='MN'）   print(dj)#输出['PW', 'a', 'M', 'N']

◆append函数：添加一个元素

list1 = [1,2,3,4]   list1.append('duoceshi')   print (list1)

◆extend函数：连接两个列表

list1=[1,2,3,4,5]   list2 =[6,7,8]    list1.extend(list2)

print(list1) #输出[1, 2, 3, 4, 5, 6, 7, 8]

★注意：

Øextend与append方法的相似之处在于都是将新接收到参数放置到已有列表的后面。

Øappend方法可以接收任意数据类型的参数，并且追加到list尾部；Øextend方法一般和列表还有字符串进行拼接，不能与int进行拼接。

◆insert(index,value)函数：在指定位置插入一条数据

list1 = [1,2,3,4]  list1.insert(0,'test') print(list1)

#输出['test', 1, 2, 3, 4]

◆remove函数：移除元素

list1 = [1,2,3,4,1]     list1.remove(1)#输出[2,3,4,1]

★注：如果列表中有多个相同的元素，会删除前面那个

◆del函数：索引删除值

list1 = [1,2,3,4]      del list1[0] #输出[2,3,4]

◆index函数：在列表中查找元素所对应的索引值

list1 = [1,2,3,4]    print(list1.index(1))#输出0

◆sort函数：实现列表的排列

list1 = [1,2,3,4,1]   list1.sort()   print(list1)

python 编程基础课程https://edu.csdn.net/course/detail/36170

#输出[1, 1, 2, 3, 4]

◆sorted函数：实现列表的降序排列

list1 = [1,2,3,4,1]   Øprint(sorted(list1,reverse=True))#输出[4, 3, 2, 1, 1]降序排序

Øprint(sorted(list1,reverse=False))#输出[1, 1, 2, 3, 4]升序排序

reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）

★sort 与 sorted 区别：

Øsort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

Ølist 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

◆reverse函数：列表元素反转 

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

#输出[4, 3, 2, 1]

◆pop函数：

list1 = [1,2,3,4]  print(list1.pop(2))#输出3

Print(list1.pop())#输出4

 Ø默认移除列表最后一个元素,并返回元素的值

 Ø移除指定位置的元素list1.pop(0)表示移除第一个元素

 Ø在列表中pop函数是唯一一个既能改变列表元素又有返回值

◆列表中文打印乱码解决方法

a = [1,2,3,"中国"]    print (str(a).decode('string_escape'))

 Ødecode()：指定编码格式

 Ø★string-escape：编码格式，能解决因为被\转义的问题

3.4  Python中的元组

 3.4.1  Python中的元组定义

元组(tuple):是Python中常用的一种数据结构。元组由不同的元素组成，每个元素可以存储不同类型的数据，如字符串、数字、甚至元组。元组是'写保护'的，即元组中元素作为一个整体，创建后不能再做任何修改操作。

◆元组表达符为：()

◆元组的定义：tuple1=（1,2,3）

★注意：当元组只有一个元素时,后面要加逗号,如:tuple1=(1,)

 3.4.2  元组中常见的操作

◆元组与列表呼出方式类似  

turple1=('a','b','c','d')   print(tuple[0])

◆元组转换为列表

tuple1 = ('a','b','c','d')   list1=list(tuple1)

print(list1,type(list1))

◆列表转换为元组

list1=[1,2,3,4]            tuple1=tuple(list1) print(tuple1,type(tuple1))

◆元组中的值是不可以直接改变的

tuple1=('a','b','c')     tuple1.insert(0,'d')

print(tuple1)

◆元组中的值是可以间接来改变

Øtuple1 = ('a', 'b', 'c', 'd')    list1 = list(tuple1) #先改成列表       list1[1] = 'test' #通过列表改值

tuple1 = tuple(list1) #在转换成元组    print(tuple1)

★商汤科技面试题：

1>元组可以被改变吗？

当元组的元素作为一个整体时是不可以改变的，但是可以间接进行修改。首先把元组转换为列表，再进行修改元素，修改后再转换成元组

2>元组和列表的区别？

Ø定义符不一样.元组是(),列表是[],list表示列表，tuple表示元组

Ø元组是不能被修改的，列表是可以被修改的

Ø元组用于储存异构数据。即当做一个没有字段名的记录来使用，比如用元组来记录一个人的身高、体重、年龄信息，记录形式为：

person=(‘zhangsan’,180,80,20)

list[‘香蕉’,‘苹果’，‘猕猴桃’]

Ø元组是不可变类型，大小固定，列表是可变数据类型，数据可以动态变化，所以在内存占用方面，同样大小的数据，元组占用内存更少

3>如何修改列表里的元素

List=[1,2,3,4,5,6]#定义一个列表   list[0]=9#通过索引的方式把要修改的元素取出并进行赋值。以及通过一些列表函数修改元素   print(list)

4>如何修改元组中列表里的元素，比如把大娃改成大总

tuple=('董事长','总经理','合伙人',['大娃','二娃','三娃','四娃'])
tuple[3][0]='大总'     print(tuple)#输出('董事长', '总经理', '合伙人', ['大总', '二娃', '三娃', '四娃'])

3.4.3元组和列表的区别

★相同：  Ø都是序列类型的容器对象，可以存放任何类型的数据

        Ø支持切片、迭代等操作

★不同：  Ølist 是可变的对象，元组tuple是不可变的对象

        Øtuple不可变，所以使用tuple可以使代码更安全

3.5  Python中的字典和集合

3.5.1  Python中的字典定义

字典(dict):是另一种可变容器模型，且可存储任意类型对象。存放一系列具有映射关系的数据结构，字典是无序的，是以key：value的形式存储数据

◆字典的每个键值key：value对用冒号:分割，每个键值对之间用逗号分割，整个字典包括在大括号{}中

◆字典同时是无序，字典都是以键值对的形式存在，先键后值，键是唯一的，值且不唯一

◆字典表达符：{}

◆字典的定义方式：

 Ø法一:dict1={'name':'dishini','age':18} #通过{}直接定义

 Ø法二:list = [('a',1),('b',2),('c',3)] dict2 = dict(list) #通过dict()方法定义

取值：通过key取value，例：dict==dict(list)  print(dict)

3.5.2  字典中常见的函数

◆添加一个键值对

Ødict1 = {"name":"xiaowang","age":"10"}

dict1['class']=1834 如果字典里已经有这个键，旧数据将会替换

print(dict1)

Ø#设置键绝对setdefault 类似添加
dict={'name':'zhangsan','age':18}

dict.setdefault('sex','男')  print(dict)

#输出{'name': 'zhangsan', 'age': 18, 'sex': '男'}
Ø#如果字典存在键时，此时设置键值无效
dict.setdefault('sex','女')      print(dict)

#输出{'name': 'zhangsan', 'age': 18, 'sex': '男'}

◆字典添加元素setdefault（）

dict1 = {'name':xiaowang,'age':18}

dict1.setdefault('sex','1')

print (dict1)

注：如果插入数据键已经在字典里,插入是不生效的,默认值为空时,插入数据为None

◆del删除字典

dict1 ={"name":"xiaowang","age":"18","sex":"1"}

del (dict1)

print(dict1)

◆取出键返回列表

dict1 = {"name":"xiaowang","age":"10"}

print (dict1.keys())

或

dict1 = {"name":"xiaowang","age":"10"}

print(key)  或

                  for i in dict.keys()     #key存到i中

print(i)

◆取出值返回列表

dict1 = {"name":"xiaowang","age":"10"}

print (dict1.values())

◆取出具体键的值

 Ødict1 = {"name":"xiaowang","age":"10"}

print (dict1['name'])

Ø取出具体的键以及对应键的值

dict={'name':'zhangsan','age':18}
for key in dict:
    print(key,dict[key])#打印字典的键以及对应的值

#输出name zhangsan   age 18

Ø取出具体的键以及对应键的值，并以列表形式返回

dict={'name':'zhangsan','age':18,'sex':'男'}
for i,j in dict.items():          print(i,j)

#输出name zhangsan

age 18

sex 男

◆del删除指定的键，连同值也删除

dict1 ={"name":"xiaowang","age":"18","sex":"1"}

del (dict1["name"])

print (dict1)

◆pop(key)函数，删除指定键并返回该指定键被删除的值

dict = {'name': 'zhangsan', 'age': 18, 'sex': '男'}
print(dict.pop('name'))#输出zhangsan

◆clear()清空字典所有项

dict = {'name': 'zhangsan', 'age': 18, 'sex': '男'}

dict.clear()     print (dict)

或print(dict.clear())#输出None

再打印print(dict)#输出{}

◆get(key)方法,通过key获取值,当键不存在,返回None(接口测试常用)

dict = {'name': 'zhangsan', 'age': 18, 'sex': '男'}
print(dict.get('age'))#输出18

◆fromkeys  函数初始化，函数可以给具体的键指定值

dict={}.fromkeys(['name','age'])#初始化字典，不指定，值默认
print(dict)#输出{'name': None, 'age': None}
dict['name']='老六'#指定值
print(dict)#输出{'name': '老六', 'age': None}

◆has_key函数或__contains__函数检查字典是否有指定的键，有返回True，没有返回False

Ødict = {'name': 'zhangsan', 'age': 18, 'sex': '男'}
print(dict.__contains__('name')) #返回true,因为键存在

Ø★dict = {'name': 'zhangsan', 'age': 18, 'sex': '男'}
if dict.__contains__('nasa'):
    print('存在此键')
else:
    dict.setdefault('nasa','masike')
print(dict)

#输出{'name': 'zhangsan', 'age': 18, 'sex': '男', 'nasa': 'masike'}

◆popitem函数随机返回并删除字典中的键值对(一般删除末尾对)

如果字典已经为空，却调用了此方法，就报出KeyError异常

dict1 = {'name':xiaowang,'age':18,'class':24}

dict1.popitem()

print (dict1)#输出{'name': 'zhangsan', 'age': 18}

print (dict1.popitem())#输出('sex', '男')

print (dict1)#输出{'name': 'zhangsan', 'age': 18}

◆update函数利用一个字典更新另外一个字典
dict = {'name': 'zhangsan', 'age': 18, 'sex': '男'}
dict1={'class':1832}
dict.update(dict1)
print(dict)#输出{'name': 'zhangsan', 'age': 18, 'sex': '男', 'class': 1832}

★注意：如果要更新的元素项在原字典里存在,则把原来的项覆盖

dict = {'name': 'zhangsan', 'age': 18, 'sex': '男'}
dict1={'age':1832}
dict.update(dict1)
print(dict)#输出{'name': 'zhangsan', 'age': 1832, 'sex': '男'}

◆字典的遍历：for...in...遍历字典

dict1 = {'name':xiaowang,'age':18}

for key in dict1:

print (key,dict1[key])

◆使用items()完成遍历,取键和值

dict1= {'name':xiaowang,'age':18}

for key,value in dict1.items():

print (key,value)

3.5.3  Python中的集合

◆集合：最重要的功能就是去重

 Ø可变集合set

set1.add('dcs')

set1.remove('dcs')  

→test='hello'
m=set(test)
print(m)#输出{'h', 'e', 'l', 'o'}
print(type(m))#输出

m.clear()#清空
print(m)#输出set()

m.pop()
print(m)#输出{'e', 'o', 'l'}#把集合最前面这个给删除了

→list1 = [1,88,8,6,'hello']
list1.pop()
print(list1)#输出[1, 88, 8, 6]#把列表最后面这个给删除了

【拓】str='七夕节快乐'

for i in str:
     print(i,end='')#输出七夕节快乐

 Ø不可变集合frozenset

test = 'hello'

a = frozenset(test)

b = a.copy()

b.add('888') #报错AttributeError: 'frozenset' object has no attribute 'add'

print (b)

 python 编程基础课程https://edu.csdn.net/course/detail/36170