Python入门-基础篇笔记02

列表List

格式：list = ["str1", "str2", "str3"]

list[0] = "str1"

添加元素：list.append("str")

插入元素：list.insert(index, "str")

删除元素：list.remove("str")        del list[index]

弹出元素：list.pop(index)

sort ()与 sorted() 区别：

• 使用方法不同：list.sort()，sorted(list)
• sort方法是直接应用到列表上的，而sorted方法是生成了一个新的列表

sort函数的具体用法：Python List sort()方法 | 菜鸟教程 (runoob.com) 

示例一：

shopping_list = ["巧克力", "游戏机", "五花肉"]
print(shopping_list)
# 输出列表
shopping_list.append("ipad")
# 添加元素
print(shopping_list)
shopping_list.insert(0, "风筝")
# 插入元素
print(shopping_list)
shopping_list.remove("五花肉")
del shopping_list[3]
# 删除元素
print(shopping_list)
print(len(shopping_list))
# 输出 shopping_list 的元素个数
print(shopping_list[0])
# 输出 shopping_list 的第一个元素
shopping_list[0] = "奶茶"
# 将列表中的第一个元素即风筝换成奶茶
print(shopping_list)
print(shopping_list.pop(0))
# 弹出第一个元素
print(shopping_list)

输出：

['巧克力', '游戏机', '五花肉']
['巧克力', '游戏机', '五花肉', 'ipad']
['风筝', '巧克力', '游戏机', '五花肉', 'ipad']
['风筝', '巧克力', '游戏机']
3
风筝
['奶茶', '巧克力', '游戏机']
奶茶
['巧克力', '游戏机']

 示例二：

num_list = [2, 13, -9, 0, 99]
print(max(num_list))
# 打印列表里的最大值
print(min(num_list))
# 打印列表里的最小值
print(sorted(num_list))
# 打印排序好的列表

输出：
99
-9
[-9, 0, 2, 13, 99]

元组tuple

与列表的区别，方括号变为圆括号。因为其不可变性，不能添加或删除元素。

tuple = ("str1", "str2", "str3")

tuple.append("str") ×

创建命名元组

collections.namedtuple("Point",["x","y"])

这样就创建了一个叫做Point的命名元组类，它拥有两个属性x，y。

第二个参数["x","y"]也可以写成"x y"或者"x,y"，即用空格或者逗号隔开属性名，即：

collections.namedtuple("Point","x y")
collections.namedtuple("Point","x,y")

将其赋值给一个变量：

Point = collections.namedtuple("Point","x,y")
p = collections.namedtuple("Point","x,y") #变量名不一定要和第一个参数相同

以上得到的变量Point或者p并不直接是一个元组对象，它只是一个类，如果要创建它的实例，则需要像创建类实例一样调用它：

p1 = Point(x = 0, y = 0)
p2 = p(x = 1, y = 1)

这样就创建了两个实例p1，p2，他们的内容分别是x = 0,y = 0，x = 1,y = 1。 

访问命名元组的元素 

命名元组可以通过索引访问元素： 

print(p1[0])
print(p1[1])
# 0
# 0

 命名元组也可以通过属性访问：

print(p2.x)
print(p2.y)
# 1
# 1

修改元素 

 如果需要修改元组的元素，则不能简单的使用p1.x = 1，需要调用成员函数_replace()，它会返回一个包含新值的新实例，比如：

p1 = p1._replace(x = 1) #将p1的x值从0换到1

元组内置函数

函数名	作用
len(tuple)	计算元组中元素个数
max(tuple)	返回元组中元素的最大值
min(tuple)	返回元组中元素的最小值
tuple(seq)	将列表转换为元组

字典dict

格式：

键	：	值
key		value

（注意：键必须是不可变类型，列表就不行，int, float等可以）

dict = {key1 : value1, key2 : value2, key3 : value3}

添加元素：dict[new_key] = new_value

修改元素的值：dict[old_key] = new_value

删除元素：del dict[key]

注意键和值的类型，如果是字符串应有引号

例：

contacts = {("李四", 30):"1311111111", ("张三", 26):"174974384"}
# 元素之间用逗号隔开
print(("李四", 30) in contacts)
# 查询("李四", 30)是否在contacts中, 在返回True, 否则返回False
contacts[("李明", 39)] = "18439894"
# 添加新的元素 contacts[key] = value
del contacts[("张三", 26)]
# 删除("张三", 26)这一元素内容
print(contacts)
# 打印contacts中的内容
print(len(contacts))
# 查询contacts中的元素个数
print(contacts.keys())
# 返回所有键
print(contacts.values())
# 返回所有值
print(contacts.items())
# 返回所有键值对

输出：

True
{('李四', 30): '1311111111', ('李明', 39): '18439894'}
2
dict_keys([('李四', 30), ('李明', 39)])
dict_values(['1311111111', '18439894'])
dict_items([(('李四', 30), '1311111111'), (('李明', 39), '18439894')])

dict_name.keys()：返回所有键

dict_name.values()：返回所有值

dict_name.items()：返回所有键值对

menu = {"fish":60, "tomato":30, "beef":80, "pork":60, "cabbage":20}
for key, value in menu.items():
    print("\nkey:" + key)
    print("value:" + str(value))
print("\n")
for key in menu.keys():
    print("菜名:" + key)
print("\n")
for value in menu.values():
    print("value:" + str(value))

输出：

key:fish
value:60

key:tomato
value:30

key:beef
value:80

key:pork
value:60

key:cabbage
value:20


菜名:fish
菜名:tomato
菜名:beef
菜名:pork
菜名:cabbage


value:60
value:30
value:80
value:60
value:20

 列表和字典

列表中存储字典：

menu1 = {'fish':40, 'pork':30, 'potato':20,'noodles':15}
menu2 = {'chicken':30, 'corn':55, 'lamb':65,'onion':12}
menu3 = {'bacon':36, 'beef':48, 'crab':72,'eggs':7}
total_menu = [menu1, menu2, menu3]
print(total_menu)

输出：

[{'fish': 40, 'pork': 30, 'potato': 20, 'noodles': 15}, {'chicken': 30, 'corn': 55, 'lamb': 65, 'onion': 12}, {'bacon': 36, 'beef': 48, 'crab': 72, 'eggs': 7}]

字典中存储列表 ：

# 初始化menu菜单，里面包含配料列表
menu = {'fish':['vinegar','soy','salt'], 'pork':['sugar','wine']}
# 输出pork这道菜的配料
print('The burding of pork is:',menu['pork'])

输出：

The burding of pork is: ['sugar', 'wine']

 字典中存储字典：

# 创建一个字典menu_sum，里面包含两个子菜单字典menu1和menu2
menu_sum = {
    'menu1':{'fish':40, 'pork':30, 'potato':20,'noodles':15},
    'menu2':{'chicken':30, 'corn':55, 'lamb':65,'onion':12}
}
# 输出menu1和menu2中的菜名和价格
print(menu_sum['menu1'])
print(menu_sum['menu2'])

输出：

{'fish': 40, 'pork': 30, 'potato': 20, 'noodles': 15}
{'chicken': 30, 'corn': 55, 'lamb': 65, 'onion': 12}

collections模块 

计数器(Counter)

        计数器是一个无序容器，用于记录各种值出现的次数。它采用键值对的形式存储，要记录的值作为key，这个值出现的次数作为value，value值可正可负。

创建计数器

要创建一个计数器实例，可以调用它的无参构造函数：

c = collections.Counter()
# 创建了一个空的计数器实例c

也可以从list，tuple，dict，字符串等**可迭代对象(iterable)**创建： 

c = collections.Counter(['a','a','b','b','c']) #从list创建
c = collections.Counter(('a','a','b','b','c')) #从tuple创建
c = collections.Counter({'a':2,'b':2,'c':1}) #从dict创建
c = collections.Counter("aabbc") #从字符串创建

上面四条语句创建出来的计数器c都是相同的：

{'a': 2, 'b': 2, 'c': 1} 

也可以直接指定键值对，来创建计数器：

c = collections.Counter(a=2,b=2,c=1)

 创建出来的计数器c，与上面四条语句创建的计数器c是相同的。

访问元素

计数器是dict的子类，因此可以像使用dict那样访问计数器元素：

print(c['a'])
# 2
print(c['b'])
# 2
print(c.c)
# 1

 与dict不同的是，当访问计数器中不存在的元素的时候，不会产生异常，而是返回0，比如：

print(c['d']) #c中没有d元素，但不会发生异常
# 输出 0

增加计数与减少计数

        要改变计数器中某一元素的值，除了可以使用操作dict的方式：c.a = XXX外，计数器还提供了两个成员函数update和subt\fract。

update函数接受一个可迭代对象，然后将这个对象中各种值出现的次数加到计数器中，比如：

c.update("aabbcd") #字符串也是可迭代对象

上面这行语句执行后，c的值从原来的：

{'a': 2, 'b': 2, 'c': 1}

增加到了：

{'a': 4, 'b': 4, 'c': 2, 'd': 1} 

subtract函数与update函数类似，不过它是从计数器中减去可迭代对象中各种值出现的次数，比如：

c.subtract("aabbcd")

上面这行语句执行后，c的值从原来的：

{'a': 4, 'b': 4, 'c': 2, 'd': 1}

减少到了：

{'a': 2, 'b': 2, 'c': 1, 'd': 0}

删除元素 

        从上面的例子可以发现，当计数器中一个元素的值减少到0时，它并不会自动从计数器中删除，如果要删除元素，可以使用del函数：

del(c['d'])

上面这行语句执行后，c的值从原来的：

{'a': 2, 'b': 2, 'c': 1, 'd': 0}

变成了：

{'a': 2, 'b': 2, 'c': 1}  

即元素d被删除了。

TopN操作 

        计数器还提供了一个获取出现次数最多的n个元素的成员函数most_common，它返回包含这些元素的list，比如：

top1 = c.most_common(1) #出现次数最多的元素
print(top1)
top2 = c.most_common(2) #出现次数最多的两个元素
print(top2)
all = c.most_common() #不提供参数则返回所有元素
print(all)

得到的结果是：

[('a', 2)]
[('a', 2), ('b', 2)]
[('a', 2), ('b', 2), ('c', 1)]

 注意：如果有多个元素的值相同，那么它们之间的顺序是不可确定的，不要在它们的顺序上作任何假设。

双向队列 (deque) 

        双向队列是一种能在队列两端都进行入队、出队操作的数据结构，比普通的队列更加灵活也更加复杂。

创建双向队列

就像计数器Counter，双向队列可以调用无参构造函数创建一个空队列，也可以使用可迭代对象创建，并初始化一个队列，比如：

d = collections.deque() #创建一个空队列
d = collections.deque(['a','b','c']) #从list创建
d = collections.deque(('a','b','c')) #从tuple创建
d = collections.deque({'a':0,'b':1,'c':2}) #从dict创建
d = collections.deque("abc") #从字符串创建

第一行语句创建一个空队列，下面四行语句创建了含有元素a，b，c的队列，要注意当从dict创建时，使用的是它的键key，而不是值value。

队列操作 

双向队列与list类似，也有append和pop这两个成员函数，他们的作用分别是向队列的右边增加元素和从队列的右边删除并返回一个元素，比如：

d.append('d') #向右边增加一个元素'd'
print(d)
d.pop() #从右边删除一个元素
print(d)

得到的结果：

deque(['a', 'b', 'c', 'd'])
deque(['a', 'b', 'c'])

与append，pop相对应的，还有一组对队列左边进行操作的函数：appendleft，popleft，用法也与前面的一组类似：

d.appendleft('+') #向左边增加一个元素'+'
print(d)
d.popleft() #从左边删除一个元素
print(d)

得到的结果：

deque(['+', 'a', 'b', 'c'])
deque(['a', 'b', 'c'])

双向队列还提供了一对操作：extend和extendleft，用于将一个可迭代对象的所有迭代值，依次加入到队列的右边或者左边：

d1 = collections.deque()
d1.extend("123")
print(d1)
d1 = collections.deque()
d1.extendleft("123")
print(d1)

得到的结果是：

deque(['1', '2', '3'])
deque(['3', '2', '1'])

有序字典 (OrderedDict)

        有序字典和普通的dict基本上是相似的，只有一点不同，那就是有序字典中键值对的顺序会保留插入时的顺序。

创建有序字典

有序字典的创建方法和普通的dict类似，不过由于多了保留顺序的功能，因此在使用可迭代对象创建有序字典时，可以对它先排个序，让创建出来的字典元素也是有序的：

import collections

data = [('a',1),('b',3),('c',2)]
od = collections.OrderedDict(sorted(data,key=lambda s:s[0]))#按数据中key值的大小排序
print(od)
od = collections.OrderedDict(sorted(data,key=lambda s:s[1]))#按数据中value值的大小排序
print(od)

得到的结果：

OrderedDict([('a', 1), ('b', 3), ('c', 2)])
OrderedDict([('a', 1), ('c', 2), ('b', 3)])

注：这里使用的sorted函数，它返回对一个可迭代对象排序后的结果，如果可迭代对象的元素不能直接进行比较（比如元素是一个list或tuple等），则需要指定key函数。

这里使用lambda表达式lambda s:s[0]和lambda s:s[1]，分别指定key为data中每个元素（tuple类型）的第一个元素和第二个元素。

修改顺序

有序字典提供了一个move_to_end函数，这个函数可以将指定的键值对移动到最前面或者最后面，即最左边或最右边：

import collections

dt = collections.OrderedDict()
dt['a'] = 0
dt['b'] = 1
dt['c'] = 2
dt.move_to_end('b',last = False) #将`b`键值对移动到最前方
print(dt)
dt.move_to_end('b',last = True) #将`b`键值对移动到最后方
print(dt)

得到的结果：

OrderedDict([('b', 1), ('a', 0), ('c', 2)])
OrderedDict([('a', 0), ('c', 2), ('b', 1)])

默认字典 (defaultdict)

默认字典的功能与dict基本相同，但在访问一个不存在的key时，默认字典会提供一个默认值，而不是引发异常。 

创建默认字典

默认字典的构造函数接受一个工厂函数default_factory作为参数，可以将一个类型名看做是一个工厂函数，比如list，tuple，str等。 这个函数会在要生成默认值的时候无参调用，如果使用类型名作为工厂函数，则这个类型必须要有无参构造函数，比如：

dd = collections.defaultdict(int) #使用int作为工厂函数
print(dd['a']) #访问不存在的key:'a'
dd = collections.defaultdict(tuple) #使用tuple作为工厂函数
print(dd['a']) #访问不存在的key:'a'
dd = collections.defaultdict(str) #使用str作为工厂函数
print(dd['a']) #访问不存在的key:'a'
class Test:
    def __init__(self,name): #只有一个构造函数，而且它有一个参数
        print("init")
dd = collections.defaultdict(Test) #使用自定义类型Test作为工厂函数
print(dd['a']) #运行到这里就会出现异常，原因是Test类没有无参的构造函数

直到最后一行语句之前，上面的结果是：

0
()
 
#上一行是字符串的默认值：空字符串

如果不提供工厂函数，那么默认值的功能就失效了，此时默认字典与普通dict表现的功能一致：

dd = collections.defaultdict()
print(dd['a']) 
#虽然dd是一个默认字典，但由于没有指定工厂函数，没办法产生一个默认值，因此还是会发生异常