python程序基础知识（四）python数据结构

1.概述

	在这一节里面，我们主要会讲一下Python中能够存储系列数据的结构，那我们会想一下字符串 ，字符串虽然不是通常意义上的存储结构，
但是它也可以用来存储数据，接下来我们会讲一下Python中的Python中的三种主要数结构：列表、元组和字典。

2.字符串类型

字符串是程序中最常见的一种数据类型，字符串可以包含中英文等任何字符，存到内存时是将中英文变为Unicode的编码存储，
因此我们可以利用Unicode的编码对字符串进行一系列操作。

2.1 获取字符串的长度函数len()

print(len('abcde'))
print(len('你好，我是小明'))

其结果是：

5
7

2.2读取字符串中的各个字符

可以像访问数组元素那样用s[i]得到，字符串空格也是一个字符

s = 'hello world'
for i in range(len(s)):
    print(s[i])

其结果是：

h
e
l
l
o
 
w
o
r
l
d

2.3字符在内存中的编码

字符在计算机中实际上是用二进制来存储的，这个编码称为Unicode。
如果想知道某个字符的编码，可以使用ord(字符)这个函数

s = 'hello,你好'
for i in range(len(s)):
    print(s[i],ord(s[i]))

其结果是：

h 104
e 101
l 108
l 108
o 111
, 44
你 20320
好 22909

2.4编码转字符

如果我们知道了一个符号的编码，那我们可以通过char(编码)把它从编码转化为字符.

a = chr(104)
b = chr(101)
c = chr(108)
d = chr(108)
e = chr(111)
print(a,b,c,d,e)

其结果是：

h e l l o

2.5字符串的大小比较

字符串中的大小比较是由他们的Unicode的编码大小所决定的，一般来说编码中：数字<大写英文字母<小写英文字母<中文字符

a = '4'
b = 'A'
c = 'a'
d = '爱'
print(ord(a),ord(b),ord(c),ord(d))
print(a<b)
print(b<c)
print(c<d)

其结果是：

52 65 97 29233
True
True
True

2.6英文字母的大小写转换

英文字母在编码中是连续的26个，有大小写之分，大写与小写字母之间有固定的间隔，因此我们可以通过这个间隔将大小写字母进行转换，

大小写转换：

a = "d"
b = chr(ord(a)-ord("a")+ord("A"))
c = "D"
d = chr(ord("a")+ord(c)-ord("A"))
print(b)
print(d)

其结果是：

D
d

3.字符串常用函数

在字符串中也有一些系统提前设定好的函数，熟练掌握这些函数，可以帮助我们编程更加方便。

3.1字符串的子串切片

string[start:end:step], start为开始的位置,end为结束的位置,step是步长,嗯，中间的符号是冒号.

s = 'hello world,my name is xioaming'
l =len(s)
print(l)
print('s[0:2]:',s[0:2])
print('s[2:]:',s[2:])
print('s[:10]:',s[:10])
print('s[10:20]:',s[10:20])
print('s[10:20:2]:',s[10:20:2])
print('s[10:30:4]:',s[10:30:4])

其结果是：

31
s[0:2]: he
s[2:]: llo world,my name is xioaming
s[:10]: hello worl
s[10:20]: d,my name 
s[10:20:2]: dm ae
s[10:30:4]: d e a

3.2 字符串大小写转换函数upper(),lower()

格式：string.upper() 将一个字符串中所有字符转化为大写
格式：string.lower() 一个字符串中所有字符转化为小写

s = 'MY NAME IS XIAO MING,hello this world'
print(s)
print(s.upper())
print(s.lower())

其结果是：

MY NAME IS XIAO MING,hello this world
MY NAME IS XIAO MING,HELLO THIS WORLD
my name is xiao ming,hello this world

3.3 字符串查找函数find(),rfind(),index()

格式：string.find()  返回在字符串中查找子串第1个出现位置的下标，如果不存在就返回-1，
格式：string.rfind()  返回在字符串中查找子串最后1个出现位置的下标，如果不存在就返回-1，
格式：string.index()  返回字符串中查找子串第1个出现位置下标,如不存在就出错误，
find找不到子串会显示-1，index找不到子串则会报错，

s = 'abcdeabcdeabc'
print(s.find('abc'))
print(s.rfind('abc'))
print(s.index('abc'))
print('-------------')
print(s.find('bc'))
print(s.rfind('bc'))
print(s.index('bc'))
print('-------------')
print(s.find('gh'))
print(s.rfind('gh'))
print(s.index('gh'))

其结果是：

0
10
0
-------------
1
11
1
-------------
-1
-1
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_19244/3842988287.py in <module>
     15 print(s.find('gh'))
     16 print(s.rfind('gh'))
---> 17 print(s.index('gh'))

ValueError: substring not found

3.4 字符串判断函数startswith(),endswith()

格式：string.startswith()  判断字符串是否以子串开始,返回逻辑值，
格式：string.endswith()    判断字符串是否以子串结束,返回逻辑值，

s = 'hello world,my name is xioaming'
m = s.startswith('hello')
n = s.endswith('ming')
print(m,n)
k = s.startswith('h')
l = s.endswith('n')
print(k,l)

其结果是：

True True
True False

3.5 字符串去掉空格函数lstrip(),rstrip(),strip()

格式：string.strip()  返回一个字符串，去掉了左边与右边的空格
格式：string.lstrip() 返回一个字符串，去掉了左边的空格
格式：string.rstrip() 返回一个字符串，去掉了右边的空格
strip()也可以去掉字符串左边或右边的对应字符

s = ' hello world, '
print(s.strip())
print(s.lstrip())
print(s.rstrip())
print('-----------------')
s1 = '-hello world--'
print(s1.strip('-'))
print(s1.lstrip('-'))
print(s1.rstrip('-'))

其结果是：

hello world,
hello world, 
 hello world,
-----------------
hello world
hello world--
-hello world

3.6 字符串分离函数split(sep)

格式：string.split(sep) 用sep分割字符串，分割出来的部分组成列表返回，这个函数可以说是在字符串应用中使用最多的函数。

s = 'hello world my name is xiaoming'
s1 = s.split(' ')
print(s)
print(s1)

其结果是：

hello world my name is xiaoming
['hello', 'world', 'my', 'name', 'is', 'xiaoming']

4.列表

表示程序中常用的数据类型，我们主要从增删改查这4个方面来学习数据结构。

4.1列表的简介

列表是由[]组成的，数据可以进行增删改查各种操作

list1 = ['a','b','c','d']
list2 = [1,2,3,4,5]
print(list1,list2)
print(type(list1))

其结果是：

['a', 'b', 'c', 'd'] [1, 2, 3, 4, 5]
<class 'list'>

4.2 列表的增加

可以使用append()方法来添加列表元素
格式：list.append()

list1 = ['a','b','c','d']
print(list1)
list1.append('e')
print(list1)

其结果是：

['a', 'b', 'c', 'd']
['a', 'b', 'c', 'd', 'e']

4.3 列表的删除

我们可以使用del来删除列表元素
格式：del list[index]

list1 = ['a','b','c','d']
print(list1)
del list1[1]
print(list1)

其结果是：

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

4.4 列表的更改

格式：list[index] = text    可以将列表中的一个元素变为另一个元素
格式：list.insert(index,content)  可以在列表对应地方插入一个新元素

list1 = ['a','b','c','d']
print(list1)
list1[2] = 'h'
print(list1)
list1[3] = 4
print(list1)
list1.insert(3,'k')
print(list1)

其结果是：

['a', 'b', 'c', 'd']
['a', 'b', 'h', 'd']
['a', 'b', 'h', 4]
['a', 'b', 'h', 'k', 4]

4.4 列表的查询

list[start:end:step] 可以查询列表中的值,用法和字符串中的类似
使用in或not in 来判断一个元素是否在不在列表中，返回值为逻辑值

list1 = ['a','b','c','d','e','f']
print(list1[3])
print(list1[:5])
print(list1[3:])
print(list1[1:5:2])

print('-----------')
print('a' in list1)
print('a' not in list1)
print('k' in list1)
print('k' not in list1)

其结果是：

d
['a', 'b', 'c', 'd', 'e']
['d', 'e', 'f']
['b', 'd']
-----------
True
False
False
True

４.4列表的联合

用‘+’来连接多个链表

list1 = ['a','b','c']
list2 = [1,2,3,4]
list3 = list1 + list2
print(list3)

其结果是：

['a', 'b', 'c', 1, 2, 3, 4]

5.元组

tuple类型,是Python中一种类似于列表，但是只可以进行读取操作的数据结构，可以看作一个只读的列表。用()来表示

5.1 元组的简介

t = (1,2,3,4,5)
print(t)
print(type(t))

其结果是：

(1, 2, 3, 4, 5)
<class 'tuple'>

5.2 元组的查询

元组的查询和列表类似

t = ('a','b','c','d','a','e','f','g')
print(t)
print(t[3])
print(t[1:3])
print(t[3:])
print(t[:5])
print(t[1:5:2])

其结果是：

('a', 'b', 'c', 'd', 'a', 'e', 'f', 'g')
d
('b', 'c')
('d', 'a', 'e', 'f', 'g')
('a', 'b', 'c', 'd', 'a')
('b', 'd')

5.3 元组与函数

如果在函数参数末尾使用"*"参数，那么这个参数是可以变化的，一般标注为*args参数,在函数中成为一个元组，
这样的参数必须放在函数参数的末尾

def fun(a,b,*args):
    print(a,b)
    print(args)
fun(1,2)
fun(1,2,3)
fun(1,2,3,4,5,6)

print('--------------')
def min(*args):
    a = args[0]
    for i in range(len(args)):
        if a > args[i]:
            a = args[i]
    print('最小值是：',a)
    
min(1,2,3,4)
min(5,8,9,2,4,6,5,7,2)

其结果是：

1 2
()
1 2
(3,)
1 2
(3, 4, 5, 6)
--------------
最小值是： 1
最小值是： 2

6.字典

字典是Python中一种比较特殊的数据类型，它分为键和值，键与值相相对应，成对出现，可以方便地解决一些一一或者一多对应的数据。

6.1字典的简介

字典是另外一种可变的数据结构，而且可以存储任何类型的数据。
格式：dict = {key:value,key:value}    字典中键必须是唯一的，但值不必，值可以是字符串、数组、元组。
字典中的键如果出现两次，则后一个出现的会被记住.

dict1 = {'name':'xiaoming','age':15,'city':['世界','中国'],'nember':(145,255)}
print(dict1)
print(type(dict1))
dict2 = {'name':'xiaoming','age':15,'city':['世界','中国'],'nember':(145,255),'name':'xiaohong'}
print(dict2)

其结果是：

{'name': 'xiaoming', 'age': 15, 'city': ['世界', '中国'], 'nember': (145, 255)}
<class 'dict'>
{'name': 'xiaohong', 'age': 15, 'city': ['世界', '中国'], 'nember': (145, 255)}

6.2 字典的增加与修改

dict['key'] = value      如果这个键在字典中已经存在，就修改它的值，如果这个键在字典中不存在，则添加新的键值对.

dict1 = {'name':'xiaoming','age':15,'city':['世界','中国'],'nember':(145,255)}
print(dict1)
dict1['age'] = 20
print(dict1)
dict1['gender'] = 'men'
print(dict1)

其结果是：

{'name': 'xiaoming', 'age': 15, 'city': ['世界', '中国'], 'nember': (145, 255)}
{'name': 'xiaoming', 'age': 20, 'city': ['世界', '中国'], 'nember': (145, 255)}
{'name': 'xiaoming', 'age': 20, 'city': ['世界', '中国'], 'nember': (145, 255), 'gender': 'men'}

6.3 字典的删除

格式：del dict[key]   删除字典中的某一个键值对，
格式：dict.clear()     清空所有的键值对

dict1 = {'name':'xiaoming','age':15,'city':['世界','中国'],'nember':(145,255)}
print(dict1)
del dict1['city']
print(dict1)
dict1.clear()
print(dict1)

其结果是：

{'name': 'xiaoming', 'age': 15, 'city': ['世界', '中国'], 'nember': (145, 255)}
{'name': 'xiaoming', 'age': 15, 'nember': (145, 255)}
{}

6.4 字典的查询

格式：dict[key]  可以直接得到某个键相对应的值，
格式：dict.keys() 获取字典的所有键值函数,以列表的形式返回.

dict1 = {'name':'xiaoming','age':15,'city':['世界','中国'],'nember':(145,255)}
print(dict1['name'])
print(dict1['city'])
print(dict1.keys())

其结果是：

xiaoming
['世界', '中国']
dict_keys(['name', 'age', 'city', 'nember'])

6.5 字典与函数

字典也可以作为一个函数参数，函数也可以返回一个字典.
字典作为函数参数，其特殊性在于:字典是一个全局变量，函数内部的改变也会导致函数外部字典的改变.

def fun(dict):
    dict['name'] = 'xioahong'
    dict['city'] = 'china'
dict1 = {'name':'xiaoming','age':15,'city':['世界','中国'],'nember':(145,255)}
print(dict1)
fun(dict1)
print(dict1)
print('------------')

# 函数返回一个字典
def fun1():
    dict2 = {}
    dict2['name'] = 'xiaodong'
    dict2['age'] = 23
    return dict2
dict3 = fun1()
print(dict3)
print(dict3.keys())

其结果是：

{'name': 'xiaoming', 'age': 15, 'city': ['世界', '中国'], 'nember': (145, 255)}
{'name': 'xioahong', 'age': 15, 'city': 'china', 'nember': (145, 255)}
------------
{'name': 'xiaodong', 'age': 23}
dict_keys(['name', 'age'])

6.6 字典与可变参数

Python中用"**"表示字典的可变参数,一般标识为"**kargs",这种参数kargs在函数中是一个字典，调用时必须1对1对的出现，

def fun(x,y,**kargs):
    print(x,y)
    print(kargs)
    
fun(1,2)
fun(1,2,c=3,d='a',e=5)

其结果是：

1 2
{}
1 2
{'c': 3, 'd': 'a', 'e': 5}