2016江苏高考英语答案,不要告诉妈妈哦,吉印网
优点
实践站点
列表和元组,都是 一个可以放置任意数据类型的有序集合。
l = [1, 2, 'hello', 'world'] # 列表中同时含有 int 和 string 类型的元素 l [1, 2, 'hello', 'world'] tup = ('jason', 22) # 元组中同时含有 int 和 string 类型的元素 tup ('jason', 22)
list()
和 tuple()
函数相互转换;列表和元组存储方式的差异
由于列表是动态的,所以它需要存储指针,来指向对应的元素。增加/删除的时间复杂度均为 o(1)。
l = [] l.__sizeof__() // 空列表的存储空间为 40 字节 40 l.append(1) l.__sizeof__() 72 // 加入了元素 1 之后,列表为其分配了可以存储 4 个元素的空间 (72 - 40)/8 = 4 l.append(2) l.__sizeof__() 72 // 由于之前分配了空间,所以加入元素 2,列表空间不变 l.append(3) l.__sizeof__() 72 // 同上 l.append(4) l.__sizeof__() 72 // 同上 l.append(5) l.__sizeof__() 104 // 加入元素 5 之后,列表的空间不足,所以又额外分配了可以存储 4 个元素的空间
使用场景
区别
思考题
# 创建空列表 # option a:list()是一个function call,python的function call会创建stack,并且进行一系列参数检查的操作,比较expensive empty_list = list() # option b:[]是一个内置的c函数,可以直接被调用,因此效率高 empty_list = []
字典是一系列无序元素的组合,其长度大小可变,元素可以任意的删除和改变,相比于列表和元组,字典的性能更优,特别是对于查找、添加和删除操作,字典都能在常数时间复杂度内完成。而集合和字典基本相同,唯一的区别,就是集合没有件和值的配对,是一系列无序的、唯一的元素组合。
# 定义字典 d = {'name': 'jason', 'age': 20} # 增加元素对'gender': 'male' d['gender'] = 'male' # 增加元素对'dob': '1999-02-01' d['dob'] = '1999-02-01' d {'name': 'jason', 'age': 20, 'gender': 'male', 'dob': '1999-02-01'} # 更新键'dob'对应的值 d['dob'] = '1998-01-01' # 删除键为'dob'的元素对 d.pop('dob') '1998-01-01' d {'name': 'jason', 'age': 20, 'gender': 'male'} # 定义集合 s = {1, 2, 3} # 增加元素 4 到集合 s.add(4) s {1, 2, 3, 4} # 从集合中删除元素 4 s.remove(4) s {1, 2, 3} d = {'b': 1, 'a': 2, 'c': 10} # 根据字典键的升序排序 d_sorted_by_key = sorted(d.items(), key=lambda x: x[0]) # 根据字典值的升序排序 d_sorted_by_value = sorted(d.items(), key=lambda x: x[1])
可以使用 get(key,default) 函数来进行字典索引。如果键不存在,调用该函数可以返回一个默认的值。
集合不支持索引操作,因为集合本质上是一个哈希表,和列表不一样。
字典和集合性能
字典和集合是进行性能高度优化的数据结构,特别是对于查找、添加和删除操作。
字典和集合的工作原理
字典和集合的内部结构都是一张哈希表
插入操作
每次向字典或集合插入一个元素时,python 会首先计算键的哈希值(hash(key)),再和 mask = pydicminsize - 1 做与操作,计算这个元素应该插入哈希表的位置 index = hash(key) & mask。如果哈希表中此位置是空的,那么这个元素就会被插入其中。而如果此位置已被占用,python 便会比较两个元素的哈希值和键是否相等。
查找操作
先通过哈希值找到目标位置,然后比较哈希表这个位置中元素的哈希值和键,与需要查找的元素是否相等,如果相等,则直接返回,否则继续查找,知道为空或抛出异常为止
删除操作
暂时对这个位置得到元素赋予一个特殊的值,等到重新调整哈希表的大小时,再将其删除。
输入输出基础
生产环境中使用强制转换时,请记得加上 try except
文件输入输出
所有 i/o 都应该进行错误处理。因为 i/o 操作可能会有各种各样的情况出现,而一个健壮(robust)的程序,需要能应对各种情况的发生,而不应该崩溃(故意设计的情况除外)。
json 序列化与实战
优点:
map(function,iterable)
表示对 iterable 中的每个元素,都运用 function 这个函数,最后返回一个新的可遍历的集合。
def square(x): return x**2 squared = map(square, [1, 2, 3, 4, 5]) # [2, 4, 6, 8, 10]
filter(function,iterable)
表示对 iterable 中的每个元素,都使用 function 判断,并返回 true 或者 false,最后将返回 true 的元素组成一个新的可遍历的集合。
l = [1, 2, 3, 4, 5] new_list = filter(lambda x: x % 2 == 0, l) # [2, 4]
reduce(function,iterable)
规定它有两个参数,表示对 iterable 中的每个元素以及上一次调用后的结果,运用 function 进行计算,所以最后返回的是一个单独的数值。
l = [1, 2, 3, 4, 5] product = reduce(lambda x, y: x * y, l) # 1*2*3*4*5 = 120
基本概念
三要素:
if __name__ == "__main__"
来避开 import 时执行;==
表示比较对象间的值是否相等,而 is
表示比较对象的标识是否相等,即它们是否指向同一个内存地址。is
效率优于 ==
,因为 is
操作符无法被重载,执行 is
操作只是简单的获取对象的 id,并进行比较;而 ==
操作符则会递归地遍历对象的所有值,并逐一比较。常见的参数传递有 2 种:
准确来说, python 的参数传递是 赋值传递 ,或者叫做对象的 引用传递 ,python 里所有的数据类型都是对象,所以参数传递时,只是让新变量与原变量指向相同的对象而已,并不存在值传递或引用传递一说。
需要注意的是,这里的赋值或对象的引用传递,不是指一个具体的内存地址,二十指一个具体的对象。
函数也是对象
def func(message): print('got a message: {}'.format(message)) send_message = func send_message('hello world') # 输出 got a message: hello world
函数可以作为函数参数
def get_message(message): return 'got a message: ' + message def root_call(func, message): print(func(message)) root_call(get_message, 'hello world') # 输出 got a message: hello world
函数可以嵌套函数
def func(message): def get_message(message): print('got a message: {}'.format(message)) return get_message(message) func('hello world') # 输出 got a message: hello world
函数的返回值也可以是函数对象(闭包)
def func_closure(): def get_message(message): print('got a message: {}'.format(message)) return get_message send_message = func_closure() send_message('hello world') # 输出 got a message: hello world
简单使用装饰器
def my_decorator(func): def wrapper(): print('wrapper of decorator') func() return wrapper def greet(): print('hello world') greet = my_decorator(greet) greet() # 输出 wrapper of decorator hello world
更优雅的写法
def my_decorator(func): def wrapper(): print('wrapper of decorator') func() return wrapper @my_decorator def greet(): print('hello world') greet()
带参数的装饰器
def my_decorator(func): def wrapper(message): print('wrapper of decorator') func(message) return wrapper @my_decorator def greet(message): print(message) greet('hello world') # 输出 wrapper of decorator hello world
带自定义参数的装饰器
def repeat(num): def my_decorator(func): def wrapper(*args, **kwargs): for i in range(num): print('wrapper of decorator') func(*args, **kwargs) return wrapper return my_decorator @repeat(4) def greet(message): print(message) greet('hello world') # 输出: wrapper of decorator hello world wrapper of decorator hello world wrapper of decorator hello world wrapper of decorator hello world
上述 green() 函数被装饰以后,它的元信息会发生改变,可勇敢
greet__name__
来查看。可通过内置装饰器来解决这个问题
import functools def my_decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): print('wrapper of decorator') func(*args, **kwargs) return wrapper @my_decorator def greet(message): print(message) greet.__name__ # 输出 'greet'
类装饰器
class count: def __init__(self, func): self.func = func self.num_calls = 0 def __call__(self, *args, **kwargs): self.num_calls += 1 print('num of calls is: {}'.format(self.num_calls)) return self.func(*args, **kwargs) @count def example(): print("hello world") example() # 输出 num of calls is: 1 hello world example() # 输出 num of calls is: 2 hello world
装饰器支持嵌套使用
@decorator1 @decorator2 @decorator3 def func(): ... # 等价于 decorator1(decorator2(decorator3(func)))
装饰器使用场景:
metaclass 是 python 黑魔法级别的语言特性,它可以改变正常 python 类型的创建过程。
class mymeta(type): def __init__(self, name, bases, dic): super().__init__(name, bases, dic) print('===>mymeta.__init__') print(self.__name__) print(dic) print(self.yaml_tag) def __new__(cls, *args, **kwargs): print('===>mymeta.__new__') print(cls.__name__) return type.__new__(cls, *args, **kwargs) def __call__(cls, *args, **kwargs): print('===>mymeta.__call__') obj = cls.__new__(cls) cls.__init__(cls, *args, **kwargs) return obj class foo(metaclass=mymeta): yaml_tag = '!foo' def __init__(self, name): print('foo.__init__') self.name = name def __new__(cls, *args, **kwargs): print('foo.__new__') return object.__new__(cls) foo = foo('foo')
协程是实现并发编程的一种方式
生产者/消费者 模型
import asyncio import random async def consumer(queue, id): while true: val = await queue.get() print('{} get a val: {}'.format(id, val)) await asyncio.sleep(1) async def producer(queue, id): for i in range(5): val = random.randint(1, 10) await queue.put(val) print('{} put a val: {}'.format(id, val)) await asyncio.sleep(1) async def main(): queue = asyncio.queue() consumer_1 = asyncio.create_task(consumer(queue, 'consumer_1')) consumer_2 = asyncio.create_task(consumer(queue, 'consumer_2')) producer_1 = asyncio.create_task(producer(queue, 'producer_1')) producer_2 = asyncio.create_task(producer(queue, 'producer_2')) await asyncio.sleep(10) consumer_1.cancel() consumer_2.cancel() await asyncio.gather(consumer_1, consumer_2, producer_1, producer_2, return_exceptions=true) %time asyncio.run(main()) ########## 输出 ########## producer_1 put a val: 5 producer_2 put a val: 3 consumer_1 get a val: 5 consumer_2 get a val: 3 producer_1 put a val: 1 producer_2 put a val: 3 consumer_2 get a val: 1 consumer_1 get a val: 3 producer_1 put a val: 6 producer_2 put a val: 10 consumer_1 get a val: 6 consumer_2 get a val: 10 producer_1 put a val: 4 producer_2 put a val: 5 consumer_2 get a val: 4 consumer_1 get a val: 5 producer_1 put a val: 2 producer_2 put a val: 8 consumer_1 get a val: 2 consumer_2 get a val: 8 wall time: 10 s
区别并发和并行
python 中之所以同一时刻只运行一个线程运行,其实是由于全局解释锁的存在。但对 i/o 操作而言,当其被 block 的时候,全局解释器锁便会被释放,使气体线程继续执行。
import concurrent.futures import requests import threading import time def download_one(url): resp = requests.get(url) print('read {} from {}'.format(len(resp.content), url)) # 版本 1 def download_all(sites): with concurrent.futures.threadpoolexecutor(max_workers=5) as executor: executor.map(download_one, sites) # 版本 2 def download_all(sites): with concurrent.futures.threadpoolexecutor(max_workers=5) as executor: to_do = [] for site in sites: future = executor.submit(download_one, site) to_do.append(future) for future in concurrent.futures.as_completed(to_do): future.result() def main(): sites = [ 'https://en.wikipedia.org/wiki/portal:arts', 'https://en.wikipedia.org/wiki/portal:history', 'https://en.wikipedia.org/wiki/portal:society', 'https://en.wikipedia.org/wiki/portal:biography', 'https://en.wikipedia.org/wiki/portal:mathematics', 'https://en.wikipedia.org/wiki/portal:technology', 'https://en.wikipedia.org/wiki/portal:geography', 'https://en.wikipedia.org/wiki/portal:science', 'https://en.wikipedia.org/wiki/computer_science', 'https://en.wikipedia.org/wiki/python_(programming_language)', 'https://en.wikipedia.org/wiki/java_(programming_language)', 'https://en.wikipedia.org/wiki/php', 'https://en.wikipedia.org/wiki/node.js', 'https://en.wikipedia.org/wiki/the_c_programming_language', 'https://en.wikipedia.org/wiki/go_(programming_language)' ] start_time = time.perf_counter() download_all(sites) end_time = time.perf_counter() print('download {} sites in {} seconds'.format(len(sites), end_time - start_time)) if __name__ == '__main__': main() ## 输出 read 151021 from https://en.wikipedia.org/wiki/portal:mathematics read 129886 from https://en.wikipedia.org/wiki/portal:arts read 107637 from https://en.wikipedia.org/wiki/portal:biography read 224118 from https://en.wikipedia.org/wiki/portal:society read 184343 from https://en.wikipedia.org/wiki/portal:history read 167923 from https://en.wikipedia.org/wiki/portal:geography read 157811 from https://en.wikipedia.org/wiki/portal:technology read 91533 from https://en.wikipedia.org/wiki/portal:science read 321352 from https://en.wikipedia.org/wiki/computer_science read 391905 from https://en.wikipedia.org/wiki/python_(programming_language) read 180298 from https://en.wikipedia.org/wiki/node.js read 56765 from https://en.wikipedia.org/wiki/the_c_programming_language read 468461 from https://en.wikipedia.org/wiki/php read 321417 from https://en.wikipedia.org/wiki/java_(programming_language) read 324039 from https://en.wikipedia.org/wiki/go_(programming_language) download 15 sites in 0.19936635800002023 seconds
import asyncio import aiohttp import time async def download_one(url): async with aiohttp.clientsession() as session: async with session.get(url) as resp: print('read {} from {}'.format(resp.content_length, url)) async def download_all(sites): tasks = [asyncio.create_task(download_one(site)) for site in sites] await asyncio.gather(*tasks) def main(): sites = [ 'https://en.wikipedia.org/wiki/portal:arts', 'https://en.wikipedia.org/wiki/portal:history', 'https://en.wikipedia.org/wiki/portal:society', 'https://en.wikipedia.org/wiki/portal:biography', 'https://en.wikipedia.org/wiki/portal:mathematics', 'https://en.wikipedia.org/wiki/portal:technology', 'https://en.wikipedia.org/wiki/portal:geography', 'https://en.wikipedia.org/wiki/portal:science', 'https://en.wikipedia.org/wiki/computer_science', 'https://en.wikipedia.org/wiki/python_(programming_language)', 'https://en.wikipedia.org/wiki/java_(programming_language)', 'https://en.wikipedia.org/wiki/php', 'https://en.wikipedia.org/wiki/node.js', 'https://en.wikipedia.org/wiki/the_c_programming_language', 'https://en.wikipedia.org/wiki/go_(programming_language)' ] start_time = time.perf_counter() asyncio.run(download_all(sites)) end_time = time.perf_counter() print('download {} sites in {} seconds'.format(len(sites), end_time - start_time)) if __name__ == '__main__': main() ## 输出 read 63153 from https://en.wikipedia.org/wiki/java_(programming_language) read 31461 from https://en.wikipedia.org/wiki/portal:society read 23965 from https://en.wikipedia.org/wiki/portal:biography read 36312 from https://en.wikipedia.org/wiki/portal:history read 25203 from https://en.wikipedia.org/wiki/portal:arts read 15160 from https://en.wikipedia.org/wiki/the_c_programming_language read 28749 from https://en.wikipedia.org/wiki/portal:mathematics read 29587 from https://en.wikipedia.org/wiki/portal:technology read 79318 from https://en.wikipedia.org/wiki/php read 30298 from https://en.wikipedia.org/wiki/portal:geography read 73914 from https://en.wikipedia.org/wiki/python_(programming_language) read 62218 from https://en.wikipedia.org/wiki/go_(programming_language) read 22318 from https://en.wikipedia.org/wiki/portal:science read 36800 from https://en.wikipedia.org/wiki/node.js read 67028 from https://en.wikipedia.org/wiki/computer_science download 15 sites in 0.062144195078872144 seconds
asyncio 是单线程的,但其内部 event loop 的机制,可以让它并发地运行多个不同的任务,并且比多线程享有更大的自主控制权。
asyncio 中的任务, 在运行过程中不会被打断,因此不会出现 race condition 的情况。尤其是在 i/o 操作 heavy 的场景下, asyncio 比多线程的运行效率更高,因此 asyncio 内部任务切换的损耗,远比线程切换的损耗要小,并且 asyncio 可以开启的任务数量,也比多线程中的线程数列多得多。
但需要注意的是,很多情况下,使用 asyncio 需要特定第三方库的支持,而如果 i/o 操作很快,并不 heavy ,建议使用多线程来解决问题。
cpython 引进 gil 主要是由于:
gil 的设计,主要是为了方便 cpython 解释器层面的编写者,而不是 python 应用层面的程序员。
可以使用
import dis
的方式将代码编译成 bytecode
阅读者的体验 > 编程者的体验 > 机器的体验
如对本文有疑问,请在下面进行留言讨论,广大热心网友会与你互动!! 点击进行留言回复
Python 实现将numpy中的nan和inf,nan替换成对应的均值
python爬虫把url链接编码成gbk2312格式过程解析
网友评论