Python学习笔记（数据结构）

第五章 数据结构

1.列表

1.1 列表的基本用法

    在 Python 中使用中括号 “ [  ] ” 来表示列表，并用逗号（英文输入格式）分隔其中的元素。

    

book =['西游记','水浒传','三国演义','红楼梦']
print(book)

(1)创建数字列表

     可以用range（）来创建数字列表

number =list(range(1,4))
print(number)

在上述代码中，range的结尾参数为4，才能创建3个列表，输出结果如下

  [1，2，3]

(2)访问列表中的值

     列表为有序集合，想要访问列表的任何元素，使用该元素的位置索引即可

car =['audi','bmw','benchi','lingzhi'] 
print(car[0])

   

      还可以使用方法  title（）获取任何列表元素

car =['audi','bmw','benchi','lingzhi'] 
print(car[0].title())

              输出结果如下：

                             Audi

string.title()

将字符串中的单词首字母大写

还可以通过序号（序号从0开始）来读取字符串的某个字符

list1 =['Apple','samsung',9999,6999];     #可以不加分号
list2 =[1,2,3,4,5,6,7];                   #可以不加分号
print("list1[0]:",list1[0])
print("list2[1:5]:",list2[1:5])

输出结果如下：

         list1[0]: Apple
         list2[1:5]: [2, 3, 4, 5]

1.2 删除列表中的重复元素并保持顺序不变

（1）可哈希的数据类型，即不可变的数据结构(数字类型（int，float，bool）字符串str、元组tuple、自定义类的对象)。

          如果列表中保存的元素是可哈希的，那么就可以使用集合和生成器实现删除列表中的重复元素并保持顺序不变

def dedupe(items):
    seen = set()
    for item in items:
        if item not in seen:
            yield item
            seen.add(item)


if __name__ == '__main__':
    a = [5, 5, 2, 1, 9, 5, 10]
    print(a)
    print(list(dedupe(a)))

函数dedupe（）实现了可哈希情况下删除重复元素的功能，输出结果如下：

[5, 5, 2, 1, 9, 5, 10]
[5, 2, 1, 9, 10]

• set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
• 大循环在整个列表中，小循环在set（）构成的seen中，同时由于按照原来大循环中的顺序进行循环，可以实现顺序不变。
• add（）函数把要传入的元素做为一个整个添加到集合中。
• yield ：用于从函数依次返回值

（2）在不可哈希的对象序列中去除重复项

def buha(items,key=None):
    seen=set()
    for item in items:
        val =item if key is None  else key(item)
        if val not in seen:
            yield item
            seen.add(val)
if __name__ =='__main__':
    a=[
      {'x':2,'y':3},
      {'x':1,'y':4},
      {'x':2,'y':3},
      {'x':2,'y':3},
      {'x':10,'y':15},
      ]
    print(a)
    print(list(buha(a,key=lambda a:(a['x'],a['y']))))

上述代码函数buha（）中的参数key的功能是设置一个函数将序列中的元素转换为可哈希的类型，这样做的目的是检测重复选项。

执行结果如下所示：

[{'x': 2, 'y': 3}, {'x': 1, 'y': 4}, {'x': 2, 'y': 3}, {'x': 2, 'y': 3}, {'x': 10, 'y': 15}]
[{'x': 2, 'y': 3}, {'x': 1, 'y': 4}, {'x': 10, 'y': 15}]

1.3 找出列表中出现次数最多的元素

如果想要找出列表中出现次数最多的元素，可以考虑使用collections模块中的Counter类，调用Counter类中的函数most_common（）来实现这个功能。

words=[
    'look','into','AAA','look','my','AAA','the',
    'AAA','the','AAA','the','eyes','not','BBB',
    'the','AAA','don'
]
from collections  import Counter
word_counts = Counter(words)
top_three =word_counts.most_common(3)
print(top_three)

输出结果如下:

[('AAA', 5), ('the', 4), ('look', 2)]

1.4 排序类定义的实例

     在Python程序中，我们可以排序一个类定义的多个实例。使用内置函数sorted（）可以接受用来调用可调用对象（callable）的参数key，而这个可调用对象会返回待排序对象中的某些值，sorted（）函数则利用这些值来比较对象。假设在程序中存在多个User对象的实例，如果想要通过属性user_id来对这些实例进行排序，则可以提供一个可调用对象将User实例作为输入，然后返回user_id。

class User:
    def __init__(self,user_id):
        self.user_id = user_id
    def __repr__(self):
        return 'User({})'.format(self.user_id)
#原来的顺序
users =['User(19)','User(17)','User(18)']
print(users)
#根据user_id排序

print(sorted(users,key=lambda u: u.user_id))
from operator import attrgetter
print(sorted(users,key=attrgetter('user_id')))

1.5使用列表推导式

    variable = [out_exp_res for out_exp in input_list if out_exp ==2]

•     out_exp_res ：列表生成元素表达式，可以说有返回值的函数
•     for out_exp in input_list ：迭代 input_list 将 out_exp 传入 out_exp_res表达式中
•     if out_exp ==2 ：根据条件过滤哪些值

实例：

squares = [x**2 for x in range(10)]
print(squares)
multiples = [i for i in range(30) if i % 3 == 0]
print(multiples)
mylist = [1,4,-5,10,-7,2,3,-1]
zheng = [n for n in mylist if n > 0]
fu = [n for n in mylist if n < 0]
print(zheng)
print(fu)

输出结果如下：

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
[1, 4, 10, 2, 3]
[-5, -7, -1]

在Python语言中可以使用 filter（）函数处理

values =['1','2','-3','-','a','4','N/A','5']
def is_int(val):
    try:
          x =int(val)
          return True
    except ValueError:
          return False
ivals = list(filter(is_int,values))
print(ivals)

输出结果如下：

['1', '2', '-3', '4', '5']

其中筛选出了 int 型的数字，去除了'a','N/A'这些。

2.元组

元组是一种特殊的列表，与列表不同的是，元组内的数据元素不会发生改变，也不能添加或删除。

2.1创建并访问元组

tup1=('Google','toppr',1997,2000)
tup2=(1,2,3,4,5,6,7)
print("tup1[0]:",tup1[0])
print("tup2[1:5]:",tup2[1:5])

输出如下：

tup1[0]: Google
tup2[1:5]: (2, 3, 4, 5)

2.2修改元组

   元组一旦创建无法修改，但是在现实程序应用中，开发者可以对元组进行组合

tup1=('Google','toppr',1997,2000)
tup2=(1,2,3,4,5,6,7)
tup3=tup1+tup2
print(tup3)
tup4=tup2+tup1
print(tup4)

输出如下：('Google', 'toppr', 1997, 2000, 1, 2, 3, 4, 5, 6, 7)
                  (1, 2, 3, 4, 5, 6, 7, 'Google', 'toppr', 1997, 2000)

2.3删除元组

   虽然不允许删除元组中的元素值，但是可以用 del 语句删除整个元组

#定义元组”tup“
tup=('Google','toppr',1997,2000)
print(tup)
del tup
print(tup)

2.4 使用内置方法操作元组

   len(tuple) ：计算元组元素个数

   max(tuple) ：返回元组中元素最大值

   min(tuple) ：返回元组中元素最小值

   tuple(seq) ：将列表转化为元组

2.5 将序列分解为单独的变量

p=(4,5)
x,y=p
print(x)
print(y)
data=['ACM',50,91.1,(2021,7,14)]
name,shares,price,date=data
print(name)
print(date)

输出结果如下：

4
5
ACM
(2021, 7, 14)

在Python程序中，*号表达式在迭代变长的元组序列中十分有用。

record = [
    ('AAA',1,2),
    ('BBB','hello'),
    ('CCC',5,3)
]
def do_foo(x,y):
    print('AAA',x,y)
def do_bar(s):
    print('BBB',s)
for tag,*arge in record:
    if tag =='AAA':
        do_foo(*arge)
    elif tag =='BBB':
        do_bar(*arge)

line='guan:ijing234://wef:678d:guan'
uname,*fields,homedir,sh =line.split(':')
print(uname)
print(homedir)

输出结果为：

AAA 1 2
BBB hello
guan
678d

3 字典

3.1 创建并访问字典

字典可以储存任意类型对，字典的每个键值对 “key：value”之间必须用冒号，每对之间用逗号，整个字典包括在大括号中。

dict ={'数学':'99','语文':'99','英语':'99'}
print("数学的成绩为",dict['数学'])
print("语文的成绩为",dict['语文'])
print("英语的成绩为",dict['英语'])

输出结果如下：

数学的成绩为 99
语文的成绩为 99
英语的成绩为 99

如果调用的字典中没有这个键，执行后会输出执行错误的提示。

3.2 添加、修改、删除字典元素

（1）添加字典元素

字典是一种动态结构，可以随时添加键值对

dict ={'数学':'99','语文':'99','英语':'99'}
dict['物理']=100
dict['化学']=98
print(dict)
print(dict['物理'],dict['化学'])

输出结果如下：

{'数学': '99', '语文': '99', '英语': '99', '物理': 100, '化学': 98}
100 98

（2）修改字典元素

                    Python中，想要修改字典中的值的话，首先指定字典名，然后用中括号把将要修改的键和新值对应起来。                 

#创建字典 “dict”
dict={'Name':'Jim','Age':'20','Class':'Six'}
dict['Age']=8
dict['School']='HEU'
print(dict)

输出结果为：

{'Name': 'Jim', 'Age': 8, 'Class': 'Six', 'School': 'HEU'}

（3）删除字典元素

#创建字典 “dict”
dict={'Name':'Jim','Age':'20','Class':'Six'}
dict['Age']=8
dict['School']='HEU'
del dict['Age']
print(dict)

  输出结果为：   

{'Name': 'Jim', 'Class': 'Six', 'School': 'HEU'}

3.3 映射多个值

   Python可以创建将某个值（key）映射到多个值的字典，即一键多值字典。为了方便创建映射多个值的字典，可以使用内置函数 collection 中的 defaultdict 类来实现。defaultdict 类的一个主要特点是会自动初始化第一个值，这样只需关注添加元素即可。               

①d = {
    'a':[1,2,3],
    'b':[4,5],
}
e = {
    'a':{1,2,3},
    'b':{4,5}
②}
from collections import defaultdict
③d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)
④d['a'].append(3)
print(d)
⑤d = defaultdict(set)
d['a'].add(1)
d['a'].add(2)
d['a'].add(3)
⑥print(d)
⑦d={}
d.setdefault('a',[]).append(1)
d.setdefault('a',[]).append(2)
d.setdefault('b',[]).append(3)
⑧print(d)
d={}
⑨for key,value in d :  #pairs
    if key not in d:
        d[key]=[]
    d[key].append(value)
d =defaultdict(list)
⑩print(d)
⑩①for key,value in d : #pairs
    d[key].append(value)
⑩②print(d)

 上述代码中使用了内置函数 setdefault() ，如果键不在字典中，将会添加键并将键设置为默认值   

• 在①~②部分创建了一个字典
• ③~④和⑤~⑥部分分别利用 2 种方法为字典中的键创建了相同的多键值
• ⑨~⑩和⑩①~⑩②分别演示了 2 种对一键多值字典中第一个值的初始化。

4.集合

 集合是无序不重复元素的序列。其基本功能是进行成员关系测试和删除重复的元素。Python语言规定使用大括号{}或者set函数创建集合

5.数据类型转换

函数	描述
int (X    [,base])	将X转换为整数
float（X）	将X转换为浮点数
complex  (real   [,imag])	创建一个复数
str（X）	将对象转换为字符串
repr（X）	将对象转换为表达式字符串
eval（str）	用于计算在字符串中的有效Python表达式，并返回一个对象
tuple（s）	将序列s转换为元组
list（s）	将序列s转换为列表
set（s）	转换为可变集合
dict（d）	创建一个字典，d必须是一个序列（key，value）元组
frozenset（s）	转换为不可变集合
chr（X）	将整数转换为字符
unichr（X）	将整数转换为Unicode字符
ord（X）	将字符转换为他的整数值
hex（X）	将整数转换为十六进制字符串
oct（X）	将整数转换为八进制字符串