核心知识点：python入门

一、python入门day1-day24

一、python入门day1-day24

day01-03 编程语言

python是一种强类型的解释型语言

day04 变量

变量名不能以数字开头

小整数池的范围[-5,256]，pycharm里这个范围非常大

这是为了优化内存的合理安排

指向相同数字的变量名id相同

day05 垃圾回收机制（GC机制）

为了解决没有被引用的数据（垃圾）大量占用内存导致程序崩溃

1 引用计数

a = 10 表示10被a引用了1次，a = 20 表示a和10断开链接，a与20相连接20的引用计数为1，10的引用计数为0（垃圾）

存在的问题：循环引用

l1 = ['xxx']

l2 = ['yyy']

l1.append(l2)

l2.append(l1)

# l1与l2循环引用了

# 此时['xxx']被l1引用了1次，被['yyy']引用了一次，引用计数为2

# 此时['yyy']被l1引用了1次，被['xxx']引用了一次，引用计数为2

del l1

del l2

# 按照常规['xxx']['yyy']此时的引用计数为0要被清除，但是由于循环引用的问题，他们俩彼此互相引用导致引用计数失效

2 标记清除

标记清除是当内存即将被程序占满的时候，把程序停下来，进行标记清除

标记清除分为两步：

标记
- 遍历所有的GC Roots对象（栈区内所有的名字或者线程），将所有可以被直接或者间接访问到的堆区对象标记存活
清除
- 遍历堆区所有对象，没有被标记的就清除。

刚刚循环引用的地方，堆区的两个列表虽然互相引用，但是他们没有被栈区的任何对象直接或者间接访问，所以没有被标记，就被清除了。

3 分代回收

分代回收解决了引用计数的第二个问题，效率

工作原理：根据栈区中名字的使用频率为他们划分代，不同代的名字扫描频率不同。

day05 程序交互与基本运算符

/ 除，显示小数点

// 取整除，不显示小数点

解压赋值

num = [1,2,3,4]

# 全部解压

a,b,c,d = num

>>> a=1 b=2 c=3 d=4

# 部分解压

a,b,*_=num

>>> a=1 b=2

day06 可变不可变类型

可变类型：列表，字典（key：不可变类型，value：任意类型）

不可变类型：整形，浮点型，字符串，bool

day07 流程控制

深浅拷贝

1 赋值 =

l1 = [1,2,[3,4]]

l2 = l1

# 这时候l1 就是l2，id相同，对l1内部的可变类型不可变类型的修改都会影响l2

2 浅拷贝 copy

l1 = [1,2,[3,4]]

l2 = l1.copy()

# 把l1内部的第一层内存地址都copy给l2，l1和l2是两个id不同的列表

# 内部的可变类型其实是同一个，所以会同时修改

# 修改l1内部的不可变类型，l2不会跟着变

# 修改l1内部的可变类型，l2也会变

3 深拷贝 deepcopy

import copy

l1 = [1,2,[3,4]]

l2 = copy.deepcopy(l1)

# 把l1内部的第一层内存地址都copy给l2，l1和l2是两个id不同的列表

# 不同的是，可变类型会在内存中复制一份，所以修改可变类型其实是不同的

这里注意的点就是可变类型的修改和不可变类型修改的区别

不可变类型直接会断开和原数据的链接，重新链接新数据

可变类型则是在原数据上进行修改

day08-10 基本数据类型

1 字符串

strip 去掉左右两边指定字符，默认空格（扩展：rsrip，lsrip）
split 从左到右以指定字符切割，默认空格，可以指定次数，默认全部（扩展rsplit，从右到左以指定字符切割）
lower 全大写，upper 全小写
srartswith 以什么为开头，endwith 以什么为结尾

','join('hz') # 分隔字符串

>>> h,z

replace 替换字符
isdigit 判断是否纯数字
find 查找是否有指定字符有则返回索引，无则返回-1
index查找是否有指定字符，有则返回索引，无则报错
count 统计赐重复出现的个数

2 列表

append 追加元素
extend 追加可迭代对象，会自动把可迭代对象循环添加，列表会循环添加key
insert 插入
del 常规删除，没有返回值
- ```
x = ['aa','bb']

del x[0]
```
pop 索引删除，不写默认删除最后一个，返回值为删除的元素
remove 指名道姓删除，返回值为None
count 统计指定元素出现次数
index 查找指定元素索引
clear 清空索引
reverse 反转列表
sort 排序

3 元组

看做是不可修改的列表

注意：元组内必须加逗号，如果一个或者没有元素的时候元组不加逗号会看成数学的括号

index 查找指定元素索引
count 统计指定元素出现次数

4 字典

get 取值，和索引取的区别是get取不到返回None，索引取不到报错
pop 删除，返回值为key
popitem 随机删除，删除的键值对以（key，value）的形式返回
update 更新，存在则修改，不存在则新增
setdefault 新增，key不存在则新增，key存在则返回原来的value值

注意：

python3.5之后的字典是有序字典，因为更新之后优化了内部字典的存值方式，把原来的二维数组分成了现在一个一维数组+一个二维数组，但是原本创建一个字典就会创建8个位置，现在是创建一个字典生成一个位置

5 集合

可以把可变类型转化成集合在转回来可以去重，但是这种去重是无序的

关系运算
- & 交集共有的
- | 合集融合去重
- — 差集某个集合单有的
- ^ 对称差集两个集合单独有的的合集
- ＞父子集判断是否包含
discard 删除，存在则删除，不存在不变化
remove 删除，存在则删除，不存在则报错
update 更新，括号内放集合，会自动与元集合取合集
pop 删除指定元素，并返回，不写删除第一个
add 添加元素，只能添加不可变类型

6 基本数据类型总结

不包含集合

按照存值个数区分
- 只能存一个值：数字，字符串
- 可以存多个值：字典，列表，元组
按访问方式区分
- 直接访问：数字
- 顺序访问/索引访问：字符串，列表，元组
- key访问：字典
可变不可变区分
- 可变：列表，字典，集合
- 不可变：数字，元组，字符串

day10 字符编码

1 ascii表

只有英文字符与数字的一一对应关系

一个英文字符对应一个字节（bytes），一个字节等于8个bit，8个bit最多包含256个数字

2 GBK（中国），Shift_JIS（日本）等等

只有对应国家的文字和英文字符与数字的一一对应关系

2字节代表一个汉字

3 unicode

此时只能转换成对应字符编码的二进制，当出现unicode的时候开始统一

所有存在的文字都有与数字的一一对应关系，而传统的GBK等字符编码也能在unicode内找到对应关系

4 utf-8

当我们出现要输入多国语言的时候，unicode就会显得很臃肿

utf-8会显得更灵活

utf-8是针对unicode的可变长度字符编码，一个英文字符占一个bytes，一个汉字占3个，生僻字占更多

day11-12 文件操作

with 上下文资源管理，会自动帮我们在次级代码结束后关闭文件

显示模式：t文本模式（默认），b二进制

操作模式：r只读（默认），w只写，a只追加，+全都能读能写

1 读相关操作：

readline 一次读一行
readlines 把文件内容按照换行符为分隔返回列表
read 读取全部内容

2 写相关操作：

write 写入全部内容
writelines 是readlines的反操作

flsh 刷新

3 文件高级操作：

f.seek(n，模式) n代表移动的字节数

0模式，参照物是文件的开头
1模式，参照物是光标当前所在位置
2模式，参照物是文件末尾，n为负数倒着移动
f.tell（）得到当前光标所在位置

day13-14 函数基础

函数的返回值如果是多个元素，会自动放在一个元组内

day15 名称空间和作用域

1 命名关键字参数：

在传参时，*后面的都是命名关键字参数

特点是必须要以关键字传参方式传

2 名称空间的存活时间

内置名称空间，解释器启动则存活，解释器关闭则销毁
全局名称空间，文件执行则存活，文件关闭则销毁
局部名称空间，调用函数时存活，调用完毕后销毁

day16 闭包函数

定义：是内嵌函数，引用了外部名称空间的名字

day17 装饰器

定义：给其他函数添加额外功能的工具

开放封闭原则：对扩展功能开放，对修改内部代码封闭（多处引用，修改可能会导致错乱）

无参装饰器只要两层函数，调用装饰器的时候不能加括号

有参装饰器需要在无参装饰器外面再加一层函数用于接收参数

修正装饰器：

functools模块下提供的一个装饰器，可以让我们在使用装饰器的时候让原函数看起来还和原来一样

from functools import wraps

def timer(func):

    @wraps(func)

    def wrapper(*args,**kwargs):

        start_time=time.time()

        res=func(*args,**kwargs)

        stop_time=time.time()

        print('run time is %s' %(stop_time-start_time))

        return res

    return wrapper

用print（help（func））来判断是否和原函数一致

day18 迭代器+生成器

1 迭代器

可迭代对象：内置有__iter__方法的对象

可迭代对象转换成迭代器对象：使用__iter__方法

迭代器对象：内置有__iter__ ，__next__方法的对象

可迭代对象：列表，字符串，字典，元组，集合，文件对象

迭代器对象：文件对象

迭代器的优点：

为序列和非序列类型提供了一种统一的取值方式
惰性计算，同一时间只存在一个数据，不会影响内存，其他数据类型存就是整体存

迭代器的缺点：

除非取完整个迭代器，不然不知道迭代器长度
无法控制取值，永远只能取下一个，如果要重新开始只能重新定义一个迭代器对象

2 生成器

生成器就是自定义迭代器，有yeild关键字的函数调用不会执行，会返回一个生成器，通过yeild关键字在指定位置挂起函数，通过__next__方法来继续执行函数直到下一次挂起或者return，yeild可以接受参数，也可以和return一样返回参数。

day19 生成式

1 三元表达式

条件成立时运行的代码 if 条件 else 条件不成立时运行的代码

2 生成式

2.1 列表生成式

l = ["a","b","c2","adsa","z"]

#需求：把列表内长度大于1的值添加到新列表new_l中

new_l = [i for i in l if len(i)>1]

2.2 字典生成式

d = {"a":1,"b":2,"c":3} # 这个d只要是个可迭代对象即可

#生成一个新的字典，key是d中的所有key，value为none

new_d = {key:None for key in d }

2.3 集合生成式

# 生成一个包含数字1-9的集合

s ={i for i in range(1,10)}

2.4 生成器表达式

g = (i for i in range(10) if i >3)

day20 匿名函数

1 lambda使用

lambda 参数1,参数2... : 返回值

2 lambda与内置函数的应用

dict1 = {"hz":10011,"lxt":1234,"hzxc":101}

res = max(dict1,key=lambda k:dict1[k])

print(res)

3 map

# 映射：把一个可迭代对象的每一个值拿出来作为函数的参数运行一次，把得到的值合并起来生成一个迭代器

l = [1,2,3,4]

res = map(lambda x:x**2,l)

4 reduce

#reduce函数可以接收三个参数，一个是函数，第二个是可迭代对象，第三个是初始值

from functools import  reduce

l = [1,2,3,4]

res = reduce(lambda x,y:x+y,l,1)

>>> 11

# 如果有初始值就会把初始值作为第一个参数传入，然后取出可迭代对象的第一个值作为第二个参数传入，得到的返回值作为下一次函数运行时的x，再把可迭代对象的第二个参数传入，一直调用函数直到可迭代对象循环结束

5 filter

#过滤列表l

l = [1,2,3,4]

res = filter(lambda x:x>3,l)

#filter会迭代列表l把得到的值传给匿名函数，如果得到结果为真，则过滤出该元素，得到一个迭代器

res >>> 4

day21模块（略）

day22-24 常用模块

1 time模块

time.time() 时间戳：从1970年到现在的秒数
time.strftime() 格式化时间
time.locatime() 结构化时间（共9个元素）

注意：结构化时间可以和时间戳互相转换，结构化时间也可以和格式化时间互相转换

2 datetime模块

datetime.datatime.now()获取当前时间，精确到毫秒，格式化时间

3 random模块

random.random() 取0到1之间的小数
random.randint(1,3) 取大于等于1，小于等于3的整数
random.randrange(1,3) 取大于等于1，小于3的整数
random.choice([1,2,3,4,5,6]) 列表或元组内部随机取一个元素
random.sample([1,2,3,4,5,6]，n) 列表或元组内部随机取n个元素组合成列表
random.uniform(1,3) 取大于1小于3的小数

l1 = [1,2,3,4,5]

random.shuffle(l1)

# 把一个列表打乱

4 os

os.path.getsize('文件路径') 计算该文件大小
os.path.dirname/basename('文件路径') 获得该文件的父级目录/获得该文件的文件名
os.path.isfile(r'文件路径') 是否是一个存在的文件，返回布尔值
os.path.isdir(r'文件路径') 是否是一个存在的目录，返回布尔值
os.path.abspath(__file__) 获取当前文件路径
os.path.dirname('文件路径') 获取当前文件路径的父级路径
os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname
os.path.exists('文件路径') 如果path存在，返回True；如果path不存在，返回False

5 sys模块

sys.path.append('文件路径') 给环境变量列表添加一个路径

通常用于解决跨文件导包的问题

6 shutil

用于拷贝文件

shutil.copy(文件1，文件2) 拷贝文件和权限
shutil.copy2(文件1，文件2) 拷贝文件和状态信息

7 json&pickle

json.loads('数据') 序列化
json.dumps('数据') 反序列化
pickle.loads('数据') 序列化
pickle.dumps('数据') 反序列化

两者的区别：json序列化成json数据可以供所有语言反序列化，pickle转化成pickle格式只能供python反序列化

8 hashlib

hash算法的模块

hash值的特点：

只要传的值一样，用同样的hash算法得到的hash值必定一样
- 可用于传输密码和验证文件的完整性
不能由hash值反解成原来的内容
只要hash算法不变，无论检验的内容由多大，hash值都是定长

基本操作：

import hashlib

pwd = 123456789

# 实例化md5对象，可以传任意参数，参数会跟着数据一起加密简称 加盐

m = hashlib.md5('盐')

m.update(pwd.encode('utf-8'))

pwd_md5 = m.hexdigest()

9 logging（略）

10 re（略）

https://www.cnblogs.com/hz2lxt/p/12614863.html