一，第一部分：基础数据类型
int
bool
str
tuple
list
dict
set
1,列表
增：append extend
删：remove pop del
改：
查：
补充：count index sort reverse
2，字典
增：setdefault fromkeys（冷门）
删：pop popitem
改：update
查：get
3，集合
增：add update
删：remove pop del
交集：intersection
并集: union
差集：difference（set1.difference(set2): set1所特有的）
4，字符串
upper
lower
title
endwith
startwith
find
index
count
strip
replace（old，new，count）
isdigit
isapha
isnumpha
5，冷门知识点
1，集合和字典是无序的。list 和 dict 是可变的；int str tuple bool 是不可变的。
2，
l1=l2 ：此时l1 和 l2 的 id 相同。
l2 = l1.copy() : 此时 l1 和 l2 的 id不同。
l2 = l1.deepcopy() : 区分copy and deepcopy。
3，字典中的fromkeys。
4，enumerate:对于一个可迭代的/遍历的对象，enumerate可以将其组成一个索引序列，得到索引和值。
二，第二部分：文件操作
1，调整光标：file.seek(0) tell:报告当前光标位置。
2，readlines:一次性读出；readline:一行一行读出。
三，第三部分：函数
1，参数 返回值问题
1，在函数有多个返回值时，若用一个返回值接收，则得到一个元组。
2，定义函数时的参数顺序：
位置参数，*args，默认参数，**kwargs。
3, 补充：args组成一个元组；kwargs可以理解成一个字典。
2，关于命名空间
上级顺序：内置>全局>局部
倒置原则
3，作用域
print()
globals:永远打印全局的名字。
locals:根据所在的不同位置输出不同的内容。
4，闭包
1，内部函数包含对外部作用域而非全局作用域名字的引用，那么该内部函数成为闭包函数。
2，函数内部定义的函数成为内部函数。
5，函数部分小知识点总结
1，nonlocal：
只能用于局部变量，找上层中离当前函数中最近一层的局部变量。
只会影响离当前函数最近一层的局部变量
2，def 函数名()
四，第四部分：装饰器
1，一个完美的装饰器
import time
def timmer(f): #装饰器函数
def inner(*args, **kwargs):
start = time.time()
ret = f(*args, **kwargs) #f(1,2) #被装饰的函数
end = time.time()
print(end - start)
return ret
return inner
@timmer #语法糖 @装饰器函数名
def func(a, b): #被装饰的函数
time.sleep(0.01)
print('老板好同事好大家好', a, b)
return '新年好！'
@timmer #语法糖 @装饰器函数名
def func1(a): #被装饰的函数
time.sleep(0.01)
print('老板好同事好大家好', a)
return '过年好！'
ret = func(1, 2) #inner()
print(ret)
ret = func1(1) #inner()
print(ret)
输出结果：
老板好同事好大家好 1 2
0.010114669799804688
新年好！
老板好同事好大家好 1
0.010992765426635742
过年好！
2,函数名记录功能的装饰器
def log(func):
def inner(*args, **kwargs):
with open('log', 'a', encoding='utf-8') as f:
f.write(func.__name__+'\n')
ret = func(*args, **kwargs)
return ret
return inner
@log
def shoplist_add():
print('增加一件物品')
@log
def shoplist_del():
print('删除一件物品')
shoplist_add()
shoplist_del()
shoplist_del()
shoplist_del()
shoplist_del()
shoplist_del()
输出结果：
增加一件物品
删除一件物品
删除一件物品
删除一件物品
删除一件物品
删除一件物品
3，warps and .name 方法
作用：可以打印出真正的函数名字。
4，多个装饰器修饰一个函数问题
方向：由上到下 由下到上
五，第五部分:迭代器 和 生成器
1，如何判别是否是 可迭代/迭代器
# Iterable 可迭代的 -- > __iter__ #只要含有__iter__方法的都是可迭代的
# [].__iter__() 迭代器 -- > __next__ #通过next就可以从迭代器中一个一个的取值
# 可迭代协议：只要含有__iter__方法的都是可迭代的
# 迭代器协议：内部含有__next__ 和 __iter__ 方法的就是迭代器
# 可迭代 和 迭代器 是两个概念
print('__iter__' in dir([].__iter__()))
print('__next__' in dir([].__iter__()))
输出结果：
True
True
from collections import Iterable
from collections import Iterator
print(isinstance([], Iterator)) #判断[]是不是一个迭代器
print(isinstance([].__iter__(), Iterator)) #判断[]是不是一个迭代器
print(isinstance([], Iterable)) #判断[]是不是可迭代的
class A:
def __iter__(self):
pass
def __next__(self):
pass
a = A()
print(isinstance(a, Iterator))
print(isinstance(a, Iterable))
输出结果：
False
True
True
True
True
2，定义问题
只要含有yield关键字的函数都是生成器函数。
yield执行之后并没有结束函数，也没有继续执行，而是可以继续接收。
生成器的本质就是迭代器。
3，从生成器中取值的方法
next
for
数据类型的强制转化
4，冷门知识:send
def generator():
print(123)
content = yield 1
print('=======', content)
print(456)
yield 2
''''''
yield
g = generator()
ret = g.__next__()
print('***', ret)
ret = g.send('Hello python') #send的效果和next一样
print('***', ret)
# send 获取下一个值的效果和next基本一致
# 只是在获取下一个值的时候，给上一yield的位置传递一个数据
# 使用send的注意事项
# 第一次使用生成器的时候 是用next获取下一个值
# 最后一个yield不能接受外部的值
输出结果：
123
*** 1
======= Hello python
456
*** 2
def init(func): #装饰器
def inner(*args, **kwargs):
g = func(*args, **kwargs) #g = average()
g.__next__()
return g
return inner
@init #相当于执行： average = init(average)
def average():
sum = 0
count = 0
avg = 0
while True:
num = yield avg
sum += num # 10
count += 1 # 1
avg = sum/count
avg_g = average() #===> inner
ret = avg_g.send(10)
print(ret)
ret = avg_g.send(20)
print(ret)
ret = avg_g.send(30)
print(ret)
ret = avg_g.send(40)
print(ret)
输出结果：
10.0
15.0
20.0
25.0
5，各种表达式
列表表达式 and 生成器表达式：
区别：括号不一样；返回值不同，列表式=是把数值直接会给出。
例子：找出含有两个 e 的名字。
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
ret = [k for name in names for k in name if k.count('e') == 2]
print(ret)
输出结果：
[‘Jefferson’, ‘Wesley’, ‘Steven’, ‘Jennifer’]
字典表达式 and 集合表达式
都是大括号；但是集合表达式自带去重功能。
六，第六部分：内置函数
1，基本知识点
内置函数一共：68个
反射相关：4
面向对象相关：9
基础数据类型相关：38
迭代器/生成器相关：3 —> range next iter
作用域相关：2 —> locals() globals()
其他：12
2，next,iter,range;
# Note: 我们平时不常用双下划綫函数，因为太麻烦。所以我们常用下面两种调用方式。
#
# 迭代器.__next__()
# next(迭代器)
#
# 迭代器 = 可迭代的.__iter__()
# 迭代器 = iter(可迭代的)
'''
range:是可迭代的，但是不是迭代器。
iter：
iter(iterable) -> iterator
Get an iterator from an object.
'''
print('__next__' in dir(range(1, 11, 2)))
print('__next__' in dir(iter(range(1, 11, 2))))
输出结果：
False
True
3，思考 题
请问为什么print能输出屏幕上？
因为print中存在变量file，而屏幕也相当于一个文件；
4，eval，exec，single；compile
'''
eval:假如我们一串字符串里面有Python的表达式，这个时候，普通情况是会把这串表达式作为字符串来输出的，
而不会执行这个表达式。如果此时，我们想执行这串字符串里面的Python表达式，使用Eval语句即可解决。
exec:假如我们一串字符串里面有Python代码，这个时候，普通情况是会把这串代码作为字符串来输出的，
而不会执行这段代码。如果此时，我们想执行这串字符串里面的Python代码，使用Exec语句即可解决。
主要区别：
Exec与Eval语句的主要区别是，Exec处理字符串里面的代码，而Eval是处理字符串里面的表达式。
'''
eval('print(123)')
exec('print(123)')
print(eval('1+2+3+4')) # 有返回值
print(exec('1+2+3+4')) #没有返回值
'''
exec:流程类
eval:计算类
single：交互类
'''
code3 = 'name = input("please input your name:")'
compile3 = compile(code3, '', 'single')
exec(compile3) #执行时显示交互命令，提示输入
print(name) #执行后name变量有值
输出结果：
123
123
10
None
please input your name:南山
南山
5，关于计算的内置函数
'''
Return the tuple (x//y, x%y).
'''
print(divmod(7, 2)) # div出发 mod取余
print(divmod(9, 5)) # 除余
'''
pow:Equivalent to x**y (with two arguments) or x**y % z (with three arguments)
'''
print(round(3.14159, 3))
print(pow(2, 3)) #pow幂运算 == 2**3
print(pow(2, 3, 3)) #幂运算之后再取余
输出结果：
(3, 1)
(1, 4)
3.142
8
2
6，all,any,zip;
'''
all: Return True if bool(x) is True for all values x in the iterable.
any: 判断是否有bool值为False的值
zip: 返回一个迭代器: 拉链形式
'''
print(all(['a', '', 123]))
print(all(['a', 123]))
print(all([0, 123]))
print(any(['', 1, 0, []]))
print('00000000000000000000000000000000000')
l = [1, 2, 3, 4, 5]
l2 = ['a', 'b', 'c', 'd']
l3 = ('*', '**', [1, 2])
d = {'k1': 1, 'k2': 2}
for i in zip(l, l2, l3, d):
print(i)
输出结果：
False
True
False
True
00000000000000000000000000000000000
(1, ‘a’, '’, ‘k1’)
(2, ‘b’, '’, ‘k2’)***
7，filter，map；
# case1: 过滤出1-100中开平方之后是整数的数字
from math import sqrt
def func(num):
res = sqrt(num)
return res % 1 == 0
ret = filter(func, range(1, 101))
for i in ret:
print(i)
'''
# filter 执行了filter之后的结果集合 <= 执行之前的个数
# filter只管筛选，不会改变原来的值
# map 执行前后元素个数不变
# 值可能发生改变
'''
# case2:
ret = map(abs, [1, -4, 6, -8])
print(ret)
for i in ret:
print(i)
输出结果：
1
4
9
16
25
36
49
64
81
100
<map object at 0x000002932F128668>
1
4
6
8
8，sort，sorted；
l = [1, -4, 6, 5, -10]
l.sort(key = abs) # 在原列表的基础上进行排序
print(l)
print(sorted(l, key=abs, reverse=True))# 生成了一个新列表,不改变原列表, but占内存
print(l) #排序之后，原列表依旧还在
l = [' ', [1, 2], 'hello world']
new_l = sorted(l, key=len) # 根据元素长度排序，同样--->key可以给一个func
print(new_l)
输出结果：
[1, -4, 5, 6, -10]
[-10, 6, 5, -4, 1]
[1, -4, 5, 6, -10]
[[1, 2], ’ ', ‘hello world’]
9，带参数key的内置函数总结；
min
max
filter
map
sorted
note: 注意区分map and filter
------>都可以和func+lamba合作
七，第七部分：递归和基本算法
1，初识递归
递归的含义就是在函数中调用自身；超过递归的最大深度之后程序会自动报错，但是最大深度可以手动调控。
2，二分法
list1 = [2, 3, 5, 10, 15, 16, 18, 22, 26, 30, 32, 35, 41, 42, 43, 55,
56, 66, 67, 69, 72, 76, 82, 83, 88]
def find(list, aim, start=0, end=None):
end = (len(list) - 1) if end is None else end
mid_index = (end - start)//2 + start
if start <= end:
if list[mid_index] < aim:
return find(list, aim, start=mid_index+1, end=end)
elif list[mid_index] > aim:
return find(list, aim, start=start, end=mid_index - 1)
else:
return '您要查找的目标是:{} \n索引值是：{}'.format(list[mid_index], mid_index)
else:
return '抱歉！列表中找不到！'
ret = find(list1, 10)
print(ret)
print('0000000000000000000000000000')
ret = find(list1, 9)
print(ret)
输出结果：
您要查找的目标是:10
索引值是：3
0000000000000000000000000000
抱歉！列表中找不到！