菜鸟笔记 Python (一)

最新推荐文章于 2023-05-24 15:45:35 发布

原创最新推荐文章于 2023-05-24 15:45:35 发布 · 384 阅读

0 ·

CC 4.0 BY-SA版权

全面解析Python编程语言，从基础语法到高级特性，涵盖函数、面向对象、错误处理、IO编程等核心内容，深入探讨模块使用、网络编程及数据库操作。

`Python`是“龟叔”在1989年打发无聊圣诞节的创作

我无聊时候在干嘛? 发呆

文章目录

`Python`是“龟叔”在1989年打发无聊圣诞节的创作

1.前言

缺点
1. 运行速度慢 解释性,翻译成CPU能理解的机器码
2. 代码不能加密 发布程序就是发布原码,编译型就是机器码发布,
版本
1. 2.x和3.x不兼容
命令行执行
1. python hello.py
输出
1. print("hello","world")中间的逗号表示输出一个空格
输入
1. input() 返回的是字符串类型

前言就到这里啦! 最最基本的东西,py本身入门也是很简单的,有编程基础的很快就可以入门

2.基础

注释
1. # 可不是什么双斜杠哦 ,双斜杠在其他地方另有含义
缩进
1. 坚持四个空格
2. 缩进使 复制-粘贴变得麻烦
数据类型
1. 整数 任意大小,永远是精确的
2. 浮点数 存在四舍五入
3. 字符串
  1. 转义字符前面加上反斜杠取消转义
  2. 单引号,双引号普通字符,存在转义
  3. 三引号原样输出,不存在转义
  4. 表示
    1. 在内存中是 Unicode
    2. 把字符送到网络或磁盘上需要编码成byte encode name=b"Primer" 注意前缀b
    3. 从网络或磁盘上读取字符需要解码 decode
  5. 格式化输出 (C语言的都理解)
    1. 方法一 %
      1. %d
      2. %f
      3. %s
      4. %x
      5. 但是用法有点特别 print("hello,%s"%("primer")) 注意百分号和括号里面的内容
    2. 方法二 format()
      1. print("hello,{0},今晚去哪? 去{1}".format("小李","派对"))
4. 布尔值
  1. 只有 True False
  2. 结合 and or not
5. 空值
  1. None
编码
1. 可变长编码 UTF-8 又一个Unicode字符,根据字符所用字节个数,编码成二进制大小
2. 获取字符的十进制数 ord(char) 只接受单个字符
3. 根据十进制数获取字符 chr(int)
4. 编码转换 string.encode(编码格式)
  1. 注意编码范围,比如中文不能使用ascii转换,中文的范围大,由输出单个字符的十进制数大小可知
list
1. 定义是使用中括号
2. 与C语言的数组无差别,有一点特殊的就是可以反向负数遍历 -1表示最后一个,以此类推
tuple
1. 不可修改
2. 定义是使用小括号
3. 只有一个元素时候需要末尾加逗号
条件判断
1. if True:
2. else :
3. elif True :
循环
1. for item in items:
  1. range(number) 生成0-number-1的整数序列
2. while True :
  1. break ,continue
字典 dict
1. Java中的map
2. d={'name':'primer'}
3. key不可变
set
1. 值不重复
2. s = set([1,2,3]) 需要提供一个list

3.函数

def 定义函数
```
def hello(x):
```
空函数 def nop(): pass
1. pass就是个占位符是代码正常运行,再无它意,但缺少就是语法错误
多返回值 return 23,456
1. 假象的多返回值,其实就是返回一个不可变的tuple,go语言的才是真的多值返回
默认参数
1. 一定要指定不变对象 def addstr(name=None):
可变参数
1. def fun(*num) 星号的使用 其实就是参数被封装为tuple传到里面去

关键参数 注意咯,一个参数就是一个字典类型

def funb(**b):
    print(b)

funb(city="japan",name="primer")

4.高级特性

切片
1. 操作对象 list tuple
2. a[0:3] 0省略
3. a[-2:-1] 倒数
4. "主函数"[:2]
迭代
1. for i in items 只要items是可迭代的对象 [如何判断对象是否可迭代? isinstance(obj,iterable)]
2. 下标迭代 for i, value in enumerate(['A', 'B', 'C']):
列表生成式
1. 生成一个列表list ? 什么样的列表,你尽管想!
生成器 generator
1. 一边循环一边计算,不一次性生成全部数据
2. (x * x for x in range(10))
3. 获取下一个元素 next(g) 调用next时候就是在计算下一个元素的值并获取

5.函数式编程

特色
1. 允许把函数本身作为参数传给函数,允许返回函数
高阶函数
1. 函数名也是变量,可以把函数名赋值给变量,那么该变量就相当于是此函数的别名
  1. map/reduce
  2. map接受一个自定义函数和序列
2. filter 过滤
  1. 过滤函数,满足条件就留下元素,否则删除
  2. 惰性函数,需要的时候才会执行过滤 怎么理解惰性? 比如已件事情,能留给明天做的绝不今天做(可我不想),能有多懒就多懒,能拖多久就拖多久
3. sorted
  1. sorted([],key)
返回函数
1. 把函数作为返回结果 这种返回其实是惰性的,你若是需要结果,则把返回的值作为函数形式再执行一次即可[就是变量后面在家一对小括号表示执行该函数]
2. 闭包
匿名函数
1. lambda x: 函数体
装饰器
1. 函数名就是变量,可以再次复制,然后调用就是 f() 加小括号形式
2. 属性__name__ 获取函数属性,比如函数名__main__就是函数入口
```
if __name__ == '__main__':
    print(__name__) #输出__main_
```
3. 所以什么是装饰器? Java中的装饰模式一样,就是:运行期间动态添加功能
  1. 本质是返回函数的高阶函数 一开始有点懵,慢慢理解
  2. decorator装饰器就是接受一个参数是函数的函数? 有点绕了? 比如:以前函数的参数是int,那么作为装饰器时候,函数的参数就是函数 ok?
偏函数
1. functools.partial 创建偏函数
2. 啥事偏函数?还没理解?
  1. 把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数

6.模块

__init__.py文件
1. 每一个包目录下面都会有一个，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包
调用另一个包中__init__.py中的函数
1. 先导入包 import primer
2. 调用函数需要加包名 primer.sayName("tom")
调用另一个包中其他 py文件的函数
1. 导入该py文件 from primer import Hello
2. 调用函数需要加py文件名 Hell.Who("tom")
作用域 Java中的public等
1. 下划线_开头的变量时 private私有的
安装第三方包
1. 方式一
  1. 工具pip 我在安装PyCharm时候勾选安装并且添加到path环境变量中了
  2. 安装 pip install name
2. 方式二
  1. Anaconda工具
  2. 导包import name

7.面向对象

类 抽象的模板

class Student(object): 
  pass

#objetc表示继承自哪一个父类,object就是终极父类,与Java中的Object是一样的

在类里面访问控制符就起很大作用了,就是下划线开头的变量或者方法名
__init__方法 两个下划线哦,我认为跟构造函数类似

class Student():

    def __init__(self,name,id):
        self.name = name
        self.id = id

    def sayName(self):
        print(self.name)

if __name__ == '__main__':
    print("程序入口")
    s = Student("老李",24)
    s.sayName()
    
    
# self代表本身,第一个参数永远是self,其余跟普通函数一致

特殊变量 __name__
1. 双下划线开始,双下划线结束
2. 可以直接访问
访问权限
1. 双下划线开头 __init__ private 不可以访问
2. 单下划线开头 _name protected 可以访问,但不建议访问
3. 其余合法字符 id 公开访问

继承 支持多继承

class Man():
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def person(self):
        print("我是人")

class Student(Man):

    def __init__(self,name,age,clazz):
        self.clazz =clazz
        self.name=name
        self.age=age

    def whoIam(self):
        print(self.name)
        print(self.age)
        print(self.clazz)

if __name__ == '__main__':
    print("程序入口")
    s = Student("老李",24,"假网工")
    s.whoIam()
    s.person()

获取对象信息
1. 判断对象类型
  1. type(obj) 返回类型
  2. isinstance(obj,str) 指定变量是否是给出的类型
2. 获取对象的所有属性和方法 dir(str)

8.面向对象高级编程

__slots__
1. 目的? 动态给类添加属性或者方法. 在Java动态语言中是很容易的,就是类似调用setName("kg");
2. 在python中呢?
  1. __slots__ = ('qq','telNumber') 就相当于是类中存在两个变量 qq telNumber [我思考也实践了一个问题就是:我若是qq加双下划线会不会是private不可访问的? 显然结果不是.我想的是,既然__slots__明确说目的是为了动态添加值,再私有化就没有意义了.]
@property
1. 保护数据不易被修改
2. 这个注解就是个装饰器 不记得装饰器是啥了? 联想动态添加功能啊,装饰模式
多继承
1. class Student(Person,Man): pass
2. Minln 就是像Java那种继承一个类,实现多个接口类似,这是一种设计
定制类
1. __str__ 不就是类似toString方法嘛 [两者的区别是__str__()返回用户看到的字符串，而__repr__()返回程序开发者看到的字符串，也就是说，__repr__()是为调试服务的。]
2. __iter__ 返回迭代对象
枚举类
1. Moth=Enum('one','tow')
2. class Moth(Enum)
元类
1. type()
  1. 判断类型 type(name)
  2. 创建类 Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class
```
1.class的名称；
2.继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
3.class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上
```
    看着优先香Java的反射[我瞎想的]
2. metaclass [听说是很难的魔法棒,可以实现ROM框架,听听就刺激,先跳过,老子也是菜鸟,暂看不懂]

9.错误处理

错误处理
1. try .. except .. finally..
调试
1. print() 自己俗称的中间变量输出
2. 断言 assert true, error message
3. logging内置日志,输出到文件 日志一般都会有日志级别
4. pdb 单步执行
5. 好好利用IDE的功能
单元测试
1. 导入测试模块 unittest
2. 编写测试类,继承导入的模块 class TestAdd(unittest.TestCase): pass
3. 然后理由self不断测试自身
4. 运行测试类
```
if __name__ == '__main__':
    unittest.main()
```
5. setUp()和tearDown()方法。这两个方法会分别在每调用一个测试方法的前后分别被执行。
文档测试
1. 执行写在注释中的代码? 什么? 震惊菜鸟,我也是第一次听说,怪我太菜 /掉头流泪狂奔
2. 使用doctest来测试

10. IO编程

文件读取
1. open(path,mode) 打开文件
2. read() 一次读完内容
3. close()
4. readlines()每次读取一行
5. 自动关闭文件
```
with open('/path/to/file', 'r') as f:
    print(f.read())
```
6. open(path,'rb')读取二进制文件
7. open(path,mode,encoding='gbk')字符编码
写文件
1. open(path,'w')
2. write(str)
3. 也可以使用上述的with自动关闭
String IO / Bytes IO
1. 在内存中读写
```
f=StringIO()
#写
f.write(str)
#读
f.getvalue()
```
2. 区别就是 StringIO操作字符串 Bytes IO操作字节
序列化
1. pickle模块
2. pickle.dumps(obj)序列化任意对象为字节流
3. pickle.load(obj)反序列化
4. josn序列化,调用的方法名一致,结果不一样

11.进程和线程

多进程
1. 在os模块中 fork()调用,子进程返回0,父进程返回子进程ID
2. fork()只能在Linux上面使用,故Windows不行,mac也是基于Linux/Unix
3. 所以在Windows上怎么使用多线程?
  1. p = Process(target=fun,args=('primer',))
  2. 这句话有些坑啊
    1. target接受的是函数名而不是函数调用
    2. args接受的是tuple
    3. 当tuple只有一个元素的时候,末尾需要加逗0号,
  3. p.start() p.join() 线程开始和等待
4. Pool线程池创建大量子线程时候使用
5. p = Pool(4) p.apply_async(target,args)
6. Pool默认大小是CPU核数,当出现线程数大于CPU核数的时候,就会出现竞争的现象
7. 子进程 subprocess
多线程
1. _thread是低级模块，threading是高级模块
2. Python解释器由于设计时有GIL全局锁，导致了多线程无法利用多核。多线程的并发在Python中就是一个美丽的梦
本地线程
1. 使用自己的局部变量,避免过多使用全局变量,对全局变量加锁使代码臃肿
分布式进程
1. Process可以分布到多台机器上，而Thread最多只能分布到同一台机器的多个CPU上。

12.常用内建模块

datetime 时间处理
1. datetime.now()当前时间
2. datetime.now().timestamp()转换成时间戳
3. datetime.fromtimestamp(time)把时间戳转换
collections 集合
namedtuple自定义tuple
deque队列
defaultdict dictkey不存在的时候抛出异常,而这个不会
ordereddict 有序的key,dict是无需的
chainmap 串联dict
counter 计数器返回还是一个tupel
base64 使用64个字符表示二进制
1. base64.b64encode(str) 编码
2. base64.b64decode(str) 解码
3. 注意
  1. str是字节流,需要使用b作为前缀
  2. 不能直接转换中文
struct
1. 处理字节数据类型
hashlib
1. 把任意数据转换成固定长度的字符串,十六进制表示
2. 常见的MD5 sha1
hmac
1. 验证数据的有效性 token对比
iteratools
1. 遍历工具
contextlib
1.
urllib
xml
htmlparser