python常用内置函数与结构

最新推荐文章于 2022-04-30 11:00:00 发布

紫薯真好吃

最新推荐文章于 2022-04-30 11:00:00 发布

阅读量255

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/ftfy123/article/details/104854852

版权

python 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

Python List pop()方法

Python 列表

描述

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

语法

pop()方法语法：

list.pop([index=-1])

参数

obj -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

返回值

该方法返回从列表中移除的元素对象。

实例

以下实例展示了 pop()函数的使用方法：

list1 = ['Google', 'Runoob', 'Taobao']
list_pop=list1.pop(1)
print "删除的项为 :", list_pop
print "列表现在为 : ", list1

Python pow() 函数

描述

pow() 方法返回 xy（x的y次方）的值。

语法

以下是 math 模块 pow() 方法的语法:

import math

math.pow( x, y )

Python sqrt() 函数

描述

sqrt() 方法返回数字x的平方根。

语法

以下是 sqrt() 方法的语法:

import math

math.sqrt( x )

注意：sqrt()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。

Python 字典(Dictionary) keys()方法

描述

Python 字典(Dictionary) keys() 函数以列表返回一个字典所有的键。

语法

keys()方法语法：

dict.keys()

参数

NA。

返回值

返回一个字典所有的键。

实例

以下实例展示了 keys()函数的使用方法：

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7}

print "Value : %s" %  dict.keys()

Python abs() 函数

描述

abs() 函数返回数字的绝对值。

语法

以下是 abs() 方法的语法:

abs( x )

Python set() 函数

集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建

集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

myset= {value01,value02,...} 
或者
set(value)

1、添加元素

语法格式如下：

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

s.add( x )

2.删除元素

参考：https://blog.csdn.net/uuihoo/article/details/79496440

1. Python字典的clear()方法（删除字典内所有元素）

dict = {'name': '我的博客地址', 'alexa': 10000, 'url': 'http://blog.csdn.net/uuihoo/'}
dict.clear();  # 清空词典所有条目

2. Python字典的pop()方法（删除字典给定键 key 所对应的值，返回值为被删除的值）

site= {'name': '我的博客地址', 'alexa': 10000, 'url':'http://blog.csdn.net/uuihoo/'}
pop_obj=site.pop('name') # 删除要删除的键值对，如{'name':'我的博客地址'}这个键值对
print pop_obj   # 输出 ：我的博客地址

3. Python字典的popitem()方法（随机返回并删除字典中的一对键和值）

site= {'name': '我的博客地址', 'alexa': 10000, 'url':'http://blog.csdn.net/uuihoo/'}
pop_obj=site.popitem() # 随机返回并删除一个键值对
print pop_obj   # 输出结果可能是{'url','http://blog.csdn.net/uuihoo/'}

4. del 全局方法（能删单一的元素也能清空字典，清空只需一项操作）

site= {'name': '我的博客地址', 'alexa': 10000, 'url':'http://blog.csdn.net/uuihoo/'}
del site['name'] # 删除键是'name'的条目 
del site  # 清空字典所有条目

实例：

>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # 这里演示的是去重功能 
{'orange', 'banana', 'pear', 'apple'} 
>>> 'orange' in basket # 快速判断元素是否在集合内 
True 
>>> 'crabgrass' in basket 
False 
>>> # 下面展示两个集合间的运算. 
>>> a = set('abracadabra') 
>>> b = set('alacazam') 
>>> a 
{'a', 'r', 'b', 'c', 'd'} 
>>> a - b # 集合a中包含而集合b中不包含的元素 
{'r', 'd', 'b'} 
>>> a | b # 集合a或b中包含的所有元素 
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'} 
>>> a & b # 集合a和b中都包含了的元素 
{'a', 'c'} 
>>> a ^ b # 不同时包含于a和b的元素 
{'r', 'd', 'b', 'm', 'z', 'l'}

类似列表推导式，同样集合支持集合推导式(Set comprehension):

实例：

>>>a = {x for x in 'abracadabra' if x not in 'abc'} 
>>> a 
{'r', 'd'}

lambda

List sort()方法和全局sorted方法

都有参数

key -- 此函数将在每个元素比较前被调用，key参数的值为一个函数，此函数只有一个参数且返回一个值用来进行比较。具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

语法

1.sort()方法：

只能对list进行排序，不能对dict字典进行排序

对list排序会修改list本身,不会返回新list，通常此方法不如sorted()方便，但是如果你不需要保留原来的list，此方法将更有效sort()。

aList = ['Google', 'Runoob', 'Taobao', 'Facebook']
aList.sort()
print ( "List : ", aList)

2.使用sorted()排序

my_dict = {"a":"1", "c":"3", "b":"2"}
result = sorted(my_dict)
print result
#输出: ['a', 'b', 'c']

sorted(set(s),key = lambda x: s.count(x), reverse = True)

可以对list，dict排序。对dict排序默认会按照dict的key值进行排序，最后返回的结果是一个对key值排序好的list

heapq 最小堆数据结构

1）、heapq.nlargest(n, iterable[, key])

从迭代器对象iterable中返回前n个最大的元素列表，其中关键字参数key用于匹配是字典对象的iterable，用于更复杂的数据结构中。

2）、heapq.nsmallest(n, iterable[, key])

从迭代器对象iterable中返回前n个最小的元素列表，其中关键字参数key用于匹配是字典对象的iterable，用于更复杂的数据结构中。

import heapq

## heapq.nlargest和heapq.nsmallest简单使用
nums = [1,8,2,23,7,-4,18,23,42,37,2]
print heapq.nlargest(3, nums)  ##从nums中找到最大的3个元素
## [42, 37, 23]
print heapq.nsmallest(3, nums)   ##从nums中找到最小的3个元素
## [-4, 1, 2]

## heapq.nlargest和heapq.nsmallest复杂结构，使用参数key
portfolio = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'HPQ', 'shares': 35, 'price': 31.75},
    {'name': 'YHOO', 'shares': 45, 'price': 16.35},
    {'name': 'ACME', 'shares': 75, 'price': 115.65}]
cheap = heapq.nsmallest(3, portfolio, key=lambda s: s['price'])
print cheap
## [{'price': 16.35, 'name': 'YHOO', 'shares': 45}, {'price': 21.09, 'name': 'FB', 
## 'shares': 200}, {'price': 31.75, 'name': 'HPQ', 'shares': 35}]
expensive = heapq.nlargest(3, portfolio, key=lambda s: s['price'])
print expensive
## [{'price': 543.22, 'name': 'AAPL', 'shares': 50}, {'price': 115.65, 'name': 'ACME',
## 'shares': 75}, {'price': 91.1, 'name': 'IBM', 'shares': 100}]

还有几个需要注意的地方：

1）heapq.heapify(iterable)：可以将一个列表转换成heapq

2）在Top N问题中，如果N=1，则直接用max(iterable)/min(iterable)即可。

3）如果N很大，接近集合元素，则为了提高效率，采用sort+切片的方式会更好，如：

求最大的N个元素：sorted(iterable, key=key, reverse=True)[:N]

求最小的N个元素：sorted(iterable, key=key)[:N]

nums = [1,8,2,23,7,-4,18,23,42,37,2]
max(nums)
## 42
min(nums)
## -4
print sorted(nums, reverse=True)[:3]
## [42, 37, 23]
print sorted(nums)[:3]
## [-4, 1, 2]