文章目录
- Python 进阶知识
- 知识点一 : 数据类型
- 1.数据类型 列表与元组
- 2.数据类型 字典与集合
- 3.数据类型 字符串
- 知识点二 : 推导式
- 1.列表推导式
- 2.字典推导式
- 3.元组推导式
- 4.集合推导式
- 知识点三 : 高阶函数
- 1.filter 函数
- 2.map 函数
- 3.reduce 函数
- 4.zip 函数
- 5.enumerate 函数
Python 进阶知识
知识点一 : 数据类型
1.数据类型 列表与元组
"""
1.列表与元组最直接的的区别是:
列表长度大小不固定,是可变的. --动态
元组长度大小固定,不可变. --静态
2.__sizeof__()方法 : Python的内置函数,用来打印系统分配空间的大小.
3.列表会一次性增加4个元素的空间,当空间使用完毕后才会继续增加 (64位操作系统中地址占用8个字节)
4.namedtuple模块 : 继承自tuple的子类,用来创建一个和tuple类似的对象,且对象拥有可访问的属性.
5.初始化空列表使用 []比 list() 快
6.非空列表与非空元组初始化时,元组的效率更高
"""
# 1.用列表检测系统如何进行空间分配
my_list = []
print("初始化大小", my_list.__sizeof__(), ":", my_list)
my_list.append("a")
print("追加1个元素之后的大小", my_list.__sizeof__(), ":", my_list)
my_list.append("b")
print("追加2个元素之后的大小", my_list.__sizeof__(), ":", my_list)
my_list.append("c")
print("追加3个元素之后的大小", my_list.__sizeof__(), ":", my_list)
my_list.append("d")
print("追加4个元素之后的大小", my_list.__sizeof__(), ":", my_list)
my_list.append("e")
print("追加5个元素之后的大小", my_list.__sizeof__(), ":", my_list)
print("--------------")
# 2.使用namedtuple模块
from collections import namedtuple
Point = namedtuple(typename='Point', field_names=['x', 'y']) # typename相当于是创建的类名,field_names用于为创建的元组的每个元素命名,可以传入列表或元组
p = Point(10, 20)
print(p.x)
print(p.y)
print("--------------")
# 3.比较 list() 与 [] 初始化效率
import timeit
a = timeit.timeit('a=list()', number=10000000 )
b = timeit.timeit('a=[]', number=10000000 )
print(a)
print(b)
print("--------------")
# 4.比较 非空元组 与 非空列表 初始化效率
import timeit
a = timeit.timeit('a=("a","b","c")', number=10000)
b = timeit.timeit('b=["a","b","c"]', number=10000)
print(a)
print(b)
print("--------------")
--------------------------------------------------
C:Users32495Envspython3.9.2Scriptspython.exe
初始化大小 40 : []
追加1个元素之后的大小 72 : ['a']
追加2个元素之后的大小 72 : ['a', 'b']
追加3个元素之后的大小 72 : ['a', 'b', 'c']
追加4个元素之后的大小 72 : ['a', 'b', 'c', 'd']
追加5个元素之后的大小 104 : ['a', 'b', 'c', 'd', 'e']
--------------
10
20
--------------
0.4988713
0.20966529999999994
--------------
0.00011539999999998773
0.0003946999999999701
--------------
进程已结束,退出代码0
2.数据类型 字典与集合
"""
1.字典:
1.1 在使用字典索引键时,若键不存在则出现KeyError错误,解决方法是在索引键时使用get(key,default)函数即可.(如 my_dict.get("F","None"))
2.集合:
2.1 集合不支持索引操作,使用索引查找对应元素值会报错(TypeError: 'set' object is not subscriptable)
2.2 集合的执行效率远高于列表
"""
# 1.字典与集合的效率问题
import time
# 1.1 计算列表运行的时间
def find_unique_weight(students):
# 声明一个统计列表
unique_list = []
# 循环所有学生数据
for id, weight in students:
# 如果体重没有在统计列表中
if weight not in unique_list:
# 新增体重数据
unique_list.append(weight)
# 计算列表长度
ret = len(unique_list)
return ret
id = [x for x in range(1, 10000)]
weight = [x for x in range(1, 10000)] # 体重数据为了计算，也设置从 1 到 10000
students = list(zip(id, weight))
start_time = time.perf_counter()
find_unique_weight(students)
end_time = time.perf_counter()
print("列表运算时间为:{}".format(end_time - start_time))
# 1.2 计算列表运行的时间
def find_unique_weight(students):
# 声明一个统计集合
unique_set = set()
# 循环所有学生数据
for id, weight in students:
# 集合会自动过滤重复数据
unique_set.add(weight)
# 计算集合长度
ret = len(unique_set)
return ret
id = [x for x in range(1, 10000)]
weight = [x for x in range(1, 10000)]
students = list(zip(id, weight))
start_time = time.perf_counter()
find_unique_weight(students)
end_time = time.perf_counter()
print("集合运算时间为:{}".format(end_time - start_time))
--------------------------------------------------
C:Users32495Envspython3.9.2Scriptspython.exe
列表运算时间为:0.6111517
集合运算时间为:0.0007663999999999449
进程已结束,退出代码0
3.数据类型 字符串
"""
1.字符串:
1.1 字符串是不可变的
1.2 字符串拼接时,join函数 比 += 快
"""
# 1.比较同名字符串内存地址
my_str = "hello "
print(id(my_str))
my_str += "world"
print(id(my_str))
print(my_str)
print("---------------")
# 2.比较字符串拼接效率
import time
# 2.1 += 写法
def m0():
s = ' '
for n in range(0, 100000):
s += str(n)
start_time = time.perf_counter()
m0()
end_time = time.perf_counter()
print("代码运行时间为:", end_time - start_time)
# 2.2 join 写法
def m1():
l = []
for n in range(0, 100000):
l.append(str(n))
s = ' '.join(l)
start_time = time.perf_counter()
m1()
end_time = time.perf_counter()
print("代码运行时间为:", end_time - start_time)
# 2.3 pythonic 写法
def m2():
s = ' '.join(map(str, range(0, 100000)))
start_time = time.perf_counter()
m2()
end_time = time.perf_counter()
print("代码运行时间为:", end_time - start_time)
--------------------------------------------------
C:Users32495Envspython3.9.2Scriptspython.exe
2625249362416
2625250809136
hello world
---------------
代码运行时间为: 0.027465000000000003
代码运行时间为: 0.022872000000000003
代码运行时间为: 0.0164642
进程已结束,退出代码0
知识点二 : 推导式
1.列表推导式
"""
1.列表推导式
1.1 推导式格式:
[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]]
1.2 if 条件表达式非必选
1.3 列表推导式运行效率高于传统for循环写法
1.4 Python3中列表推导式具备局部作用域,表达式内部变量和赋值只在局部生效
"""
# 1.传统for循环写法
my_list = [1, 2, 3]
new_list = []
for i in my_list:
new_list.append(i * 2)
print(new_list)
print("--------------")
# 2.列表推导式写法
my_list = [1, 2, 3]
new_list = []
nn_list = [i * 2 for i in my_list]
print(nn_list)
print("--------------")
# 3.列表推导式if语句
nn_list = [i * 2 for i in my_list if i > 1]
print(nn_list)
print("--------------")
# 4.列表推导式双重for循环
nn_list = [(x, y) for x in range(3) for y in range(3)]
print(nn_list)
print("--------------")
# 5.列表推导式局部性演示
x = 6
my_var = [x*2 for x in range(3)]
print(my_var)
print(x)
print("--------------")
# 6.列表推导式嵌套
my_var = [y*4 for y in [x*2 for x in range(3)]]
print(my_var)
--------------------------------------------------
C:Users32495Envspython3.9.2Scriptspython.exe
[2, 4, 6]
--------------
[2, 4, 6]
--------------
[4, 6]
--------------
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
--------------
[0, 2, 4]
6
--------------
[0, 8, 16]
进程已结束,退出代码0
2.字典推导式
"""
1.字典推导式
1.1 推导式格式:
{键:值 for 迭代变量 in 可迭代对象 [if 条件表达式]}
1.2 字典中不能出现同名key,第二次出现的同名key将会覆盖掉前一个同名key的值
"""
# 1.字典推导式演示
my_dict = {key: value for key in range(3) for value in range(2)}
print(my_dict)
print("--------------")
# 2.字典推导式遍历一个具有键值关系的可迭代对象
my_tuple_list = [('name', '王小明'), ('age', 18), ('class', 'no1'), ('like', 'python')]
my_dict = {key: value for key, value in my_tuple_list}
print(my_dict)
--------------------------------------------------
C:Users32495Envspython3.9.2Scriptspython.exe
{0: 1, 1: 1, 2: 1}
--------------
{'name': '王小明', 'age': 18, 'class': 'no1', 'like': 'python'}
进程已结束,退出代码0
3.元组推导式
"""
1.元组推导式:
1.1 元组推导式运行结果返回的是一个地址值.
"""
my_tuple = (i for i in range(10))
print(my_tuple)
--------------------------------------------------
C:Users32495Envspython3.9.2Scriptspython.exe
at 0x000001CFE12EFC10>
进程已结束,退出代码0
4.集合推导式
"""
1.集合推导式:
1.1 因为集合是无序且不重复的,所以会自动去掉重复元素导致每次运行显示的顺序不一样.
"""
my_set = {value for value in 'HelloWorld'}
print(my_set)
--------------------------------------------------
C:Users32495Envspython3.9.2Scriptspython.exe
{'d', 'e', 'r', 'l', 'o', 'W', 'H'}
进程已结束,退出代码0
知识点三 : 高阶函数
1.filter 函数
"""
1.filter 函数
1.1 函数原型:
filter ( function or None, iterable ) --> filter object
- 第一个参数是判断函数 ( 返回结果需要是 True 或 False).
- 第二个为序列,该函数将对 iterable 序列依次执行 function ( item ) 操作, 返回结果是过滤后结果组成的序列.
1.2 解释:
filter 函数对序列中元素进行筛选, 获取符号条件的序列
"""
my_list = [1, 2, 3]
my_new_list = filter(lambda x: x > 2, my_list)
print(my_new_list)
print(list(my_new_list)) # 使用list函数查看序列内容
--------------------------------------------------
C:Users32495Envspython3.9.2Scriptspython.exe
[3]
进程已结束,退出代码0
2.map 函数
"""
1.map 函数
1.1 map 函数原型:
map(func, *iterables) --> map object
1.2 解释:
map函数运行后生成一个list, 第一个参数是函数, 第二个参数是一个或多个序列
1.3 map函数解决的问题:
1.使用 map 函数不需要创建一个空列表.
2.调用函数时不再需要带括号,map 函数会自动调用目标函数.
3.map 函数会自动匹配序列中的所有元素.
"""
# 1.第一个参数为单参
my_list = [-1, 2, -3]
my_new_list = map(abs, my_list)
print(my_new_list)
print(list(my_new_list)) # 使用list函数查看序列内容
print("-----------------")
# 2.第一个参数为多参
def fun(x, y):
return x + y
my_new_list = map(fun, [1, 2, 3], [4, 4, 4]) # fun 函数有2个参数，故需要两个序列
print(my_new_list)
print(list(my_new_list))
print("-----------------")
--------------------------------------------------
C:Users32495Envspython3.9.2Scriptspython.exe
3.reduce 函数
"""
1.reduce函数
1.1 函数原型:
reduce(function, sequence[, initial]) -> value
- 第一个参数是函数
- 第二个参数是序列,返回结算结果之后的值
1.2 解释:
reduce函数用于滚动计算应用于列表中的连续值
"""
# 1.测试代码
from functools import reduce
my_list = [1, 2, 3]
def add(x, y):
return x + y
my_new_list = reduce(add, my_list)
print(my_list) # 1+2+3
print(my_new_list)
print("-----------------")
# 2.将测试代码第三个参数设置为4
my_new_list = reduce(add, my_list, 4) # 第三个参数表示初始值,即累加操作初始的数值
print(my_list) # 4 + 1+2+3
print(my_new_list)
print("-----------------")
--------------------------------------------------
C:Users32495Envspython3.9.2Scriptspython.exe
[1, 2, 3]
6
-----------------
[1, 2, 3]
10
-----------------
进程已结束,退出代码0
4.zip 函数
"""
1.zip函数
1.1 函数原型:
zip(iter1 [,iter2 [...]]) --> zip object
1.2 解释:
- zip函数将可迭代对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表.
- 如果各个迭代器的元素个数不一样,则返回列表长度与最短的对象相同,利用星号 (*)操作符将元组解压为列表
"""
# 1.测试代码
my_list1 = {1, 2, 3}
my_list2 = ["a", "b", "c"]
print(zip(my_list1, my_list2))
print(list(zip(my_list1, my_list2)))
print("-----------------")
# 2.测试代码展示*操作符
my_list = [(1, 'a'), (2, 'b'), (3, 'c')]
print(zip(*my_list))
print(list(zip(*my_list)))
print("-----------------")
--------------------------------------------------
C:Users32495Envspython3.9.2Scriptspython.exe
[(1, 'a'), (2, 'b'), (3, 'c')]
-----------------
[(1, 2, 3), ('a', 'b', 'c')]
-----------------
进程已结束,退出代码0
5.enumerate 函数
"""
1.enumerate函数:
1.1 函数原型:
enumerate(iterable, start=0)
- sequence: 一个序列、迭代器或其他支出迭代对象;
- start: 下标起始位置.
1.2 解释:
enumerate函数用于将一个可遍历的数据对象组合为一个索引序列,同时列出数据和数据下标,一般用在for循环当中.
"""
weekdays = ['Mon', 'Tus', 'Wen', 'Thir']
print(enumerate(weekdays))
print(list(enumerate(weekdays)))
--------------------------------------------------
C:Users32495Envspython3.9.2Scriptspython.exe
[(0, 'Mon'), (1, 'Tus'), (2, 'Wen'), (3, 'Thir')]
进程已结束,退出代码0
