【Python】核心数据结构：字符串、元组、列表与字典详解

字符串

字符串基础

字符串变量举例(成对的单引号，成对的双引号括起来的内容是字符串，可以将字符串赋值给变量)

str="aaa"

print(str)   #输出内容是aaa

字符串切片取值方式： [元素索引开始位置:元素索引结束位置]

索引切片取值顺序是从左到右,取值是取左不取右

str='world'

#若取rl的值可以使用以下方式
#正序方式取值

print(str[2:4])
#反序取值  

print(str[-2:-4])   

#通过索引取值为-1可以获取字符串最后一个值

print(str[-1])

strip():移除字符串头和尾指定的字符，默认是空格

str="-hello-"

print(str.strip("-"))  #hello

lstrip("charts"):移除字符串左边的空格，若不指定charts则默认是空格。

str="      hello  python"

print(str.lstrip())

print(len(str.lstrip()))

"""

hello  python  

13

"""

rstrip("charts"):移除字符串尾部指定的字符，若不指定charts则默认是空格

str="   hello  "

print(str.rstrip())

print(len(str.rstrip()))

"""

#输出结果

   hello

8

"""

split():指定字符切割字符串，默认是空格。切割后返回的类型是列

str="h-e-l-lo"
print(str.split("-"))  
#['h', 'e', 'l', 'lo']

find(str,beg,end):检测字符串中是否包含子字符串str.若存在返回字符串最小索引，若不存在返回-1

str="hello"

print(str.find("p"))   #-1

print(str.find("e"))   #1

字符串前r,b,u的作用

字符串前r表示若字符串中有转义字符则按照字符的原有模式输出

a=r"G:\stu_python\stu_request"

print(a)

#输出结果：G:\stu_python\stu_request

字符串b表示 后面的字符串是bytes类型

c=b"123qwe"

print(c)

#输出结果：b'123qwe'

字符串u表示对字符串进行unicode进行编码

b=u"A哈哈"

print(b)

#输出结果：A哈哈

python3中str和bytes转换方式

str.encode("utf-8")

bytes.decode("utf-8")


c=b"123qwe"

print(c.decode("utf-8"))

#输出结果：123qwe

元组

元组基础

1. 元组（tuple）,代表符号是（）
2. 元组内的元素可以是任何类型，元素与元素之间用“，”间隔
3. 检查变量的类型可以使用type(变量名)但会的结果是元素的类型
4. len(变量名)获取变量的长度
5. 元组内只有一个元素的时候需要在元素后面加“，”例如 name=('张三'，)
6. 元组内的值确定后不支持修改（不支持增删改）
7. 元组通过索引的方式取值，元组变量名[获取元素索引开始位置:获取元素索引结束位置]
8. 元组内包含列表则不能将元组内的列表值替换，可以将元组内元素列表的值替换。例如stu_tuple=(1,2,[6,7,8])可以将元组的最后一个元组列表内的8替换成aa

stu_tuple=('a', 'b', 'c', 'helloworld', (1, 2, 3, 4, 5, 6))

tuple_onlyone=("name",)​​​​​​​

print(tuple_onlyone)   
#('name',)​​​​​​​

print(len(stu_tuple)) 
#5

print(type(tuple_onlyone))   
#<class 'tuple'>

print(tuple_onlyone)  
#('name',)

print(stu_tuple)    
#('a', 'b', 'c', 'helloworld', (1, 2, 3, 4, 5, 6))

##采用正序的方式获取元组的值
print("采用正序的方式获取元组的值{0}".format(stu_tuple[2:4]))   
#('c', 'helloworld')
#采用反序的方式获取元组的
print("采用反序的方式获取元组的值{0}".format(stu_tuple[-4:-2]))   
#('b', 'c')
#获取stu_tuple元组内最后一个元素的第二个元素值2
print("获取stu_tuple元组内最后一个元素的第二个元素值{0}".format(stu_tuple[-1][1]))  

列表

列表基础

1. 列表(list),代表符号是[]
2. 列表内的元素可以是任何类型，元素与元素之间用“，”间隔
3. 列表内的元素可以是任何类型的数据
4. len(列表变量名获取列表的长度)
5. 列表通过索引的方式取值，列表变量名[获取元素索引开始位置:获取元素索引结束位置]
6. 列表的切片list[a:b]若a元素省略表示从第0个元素开始，若b省略则表示从a开始到列表最后一个元素。采用切片的形式将原来的列表的内存空间也指向了新列表的内存空间
7. 列表内元素支持增删改，若列表内有元组则不支持对列表内的元组进行修改
8. list值为空时返回False,list至少包含一个元素时返回True
9. max(list)返回列表中值最大的元素
10. min(list)返回列表中最小的元素​​​​​​​

列表增加元素

append():将元素添加到列表末尾

insert(索引位置,值)在列表指定索引位置添加元素，此种方法会将现有的列表元素右移

stu_list=[1,2,3,4,5,(1,2,3,4)]

#1.list.append("要添加的元素")

stu_list.append("helloworld")

print(stu_list)   #[1, 2, 3, 4, 5, (1, 2, 3, 4), 'helloworld']

stu_list.insert(-2,'python')

print(stu_list)  #[1, 2, 3, 4, 5, 'python', (1, 2, 3, 4), 'helloworld']

stu_list[-2].insert(1,'java')

print(stu_list)   #[1, 2, 3, 4, 5, 'python', (1, 2, 3, 4), ['helloworld', 'java', 'python'], 'helloworld']

列表删除元素

1. del 方式删除列表的元素需要知道列表内元素索引的位置，删除列表的元素是将列表的元素彻底删除，无法再访问。列表内的元组里面的元素不支持增删改

2. pop()删除列表最后一个元素,pop()方法删除的元素不会被彻底删除可以理解为在栈内移除

3. pop(索引位置)删除列表指定索引位置的元素

4. remove()根据要删除列表元素的值删除元素

stu_list=[1, 2, 3, 4, 5, 'python', (1, 2, 3, 4), ['helloworld', 'java', 'python'], 'helloworld']

del stu_list[4]

print(stu_list)  #[1, 2, 3, 4, 'python', (1, 2, 3, 4), ['helloworld', 'java', 'python'], 'helloworld']

#pop()删除列表最后一个元素,pop()方法删除的元素不会被彻底删除可以理解为在栈内移除

pop_stulist =stu_list.pop()

print(pop_stulist)

print(stu_list)

#pop(索引位置)删除列表指定索引位置的元素

pop_stulist=stu_list.pop(-1)

print(pop_stulist)

print(stu_list)

#remove()根据要删除列表元素的值删除元素,只能删除第一个指定的值，若要删除的值在列表中多次出现则需要使用for循环删除

stu_list.remove("python")

print(stu_list)

列表的排序

​​​​​​​list.sorted(reverse=True)方法对列表进行临时性排序reverse=True降序，reverse=False升序

list.sort(reverse=True)方法对列表元素进行永久性排序,reverse=True降序，reverse=False升序，不传reverse默认是升序排序

倒着打印列表内的元素reverse()

stu_sort=['a','d','c','b']

print(stu_sort)  #['a', 'd', 'c', 'b']

#reverse=True对元素进行降序排序

stu_sort.sort(reverse=True)

print(stu_sort)  #['d', 'c', 'b', 'a']

stu_sorted=['e','h','g','f']

print(stu_sorted) #['e', 'h', 'g', 'f']

print(sorted(stu_sorted,reverse=False))   #['e', 'f', 'g', 'h']

print(stu_sorted)  #['e', 'h', 'g', 'f']

reverse_stu=["aa","bb","cc"]

reverse_stu.reverse()

print(reverse_stu)  #['cc', 'bb', 'aa']

字典

1. 字典关键字dict  符号{}字典是键值对的形式
2. dict{"key":"value"}字典是无序的增加dict["key"]="value"不存在的key是新增，字典中已经存在的key是修改字典key下的值。
3. 获取字典值的方法：dict["key"]
4. dict.keys()获取字典的key值
5. dict.values()获取字典的value值
6. 字典在循环遍历元素的时候不支持添加元素，修改元素
7. 删除字典值的方法
   1. dict['key'].pop():删除字典指定key对应的值，返回值为被删除的值
   2. dict.popitem():随机返回并删除一个键值对
   3. dict.clear():清空字典所有条目
   4. del dict["key"]此方法是彻底删除字典中的元素

people={"name":"tom","age":14,"address":"北京","hobby":"read"}

print(people["name"])   #tom

people["age"]=18   

print(people)   #{'name': 'tom', 'age': 18, 'address': '北京', 'hobby': 'read'}

del people["hobby"]

print(people)  #{'name': 'tom', 'age': 18, 'address': '北京'}

boolean

1. None

2. False

3. 任何类型的数字0，包括0，0.0，0L,0j

4. 空的序列（sequence）或者映射（mapping）类型对象

​​​​​​​​​​​​​​​​​​​​​

作者：一个玉米栗