Pyhon大法

1.基础知识点：

1）input()函数：

输入函数的返回值类型为：str，如果需要其他数据类型需要转换函数。

2）格式化输出：

使用%：

• 建立格式化字符串
• % 变量/元组

格式化操作符：%

• %s：字符串
• %d：有符号10进制整数，%06d：表示输出的整数显示6位，不足的地方0补全
• %f：浮点数——%.02f：表示小数点后显示两位
• %%：输出%

print("单价：%.02f，重量：%.1f，占比%02d%%" % (2, 1, 1))
单价：2.00，重量：1.0，占比01%

使用format()函数：

# 对于浮点数 '0.333' 保留小数点(.)后三位
print('{0:.3f}'.format(1.0/3))
# 使用下划线填充文本，并保持文字处于中间位置
# 使用 (^) 定义 '___hello___'字符串长度为 11
print('{0:_^11}'.format('hello'))
# 基于关键词输出 'Swaroop wrote A Byte of Python'
print('{name} wrote {book}'.format(name='Swaroop', book='A Byte of Python'))

逻辑行与物理行： 如果你有一行非常长的代码，你可以通过使用反斜杠将
其拆分成多个物理行。这被称作显式行连接（Explicit Line Joining）

s = 'This is a string. \
This continues the string.'
print(s)
#输出：This is a string. This continues the string.

3）数据类型：

1.数字型：

• int
• float
• bool
• complex
  • a = 1 + 2j
  • b = complex(1, 2)
  • a ==b

2.非数字型：

• 列表
• 元组
• 字典
• 集合
• 字符串

1）非数字型数据类型特点：

• 都是序列sequence，可以看为容器；
• 可以使用[]取值；
• 使用 for in 遍历；
• 计算长度、最值、比较、删除
• 链接：+
• 重复：*
• 切片：[：]

2）公共方法

3）变量高级

4）列表：

列表的排序操作，无返回值，只是对列表的操作。

应用场景：

• 尽管列表可以存储不同类型的数据，但在开发中，
• 一般使用列表存储相同类型数据；
• 通过迭代遍历列表；

列表推导：

• 列表推导（List Comprehension） 用于从一份现有的列表中得到一份新列表。

listone = [2, 3, 4]
listtwo = [2*i for i in listone if i > 2]
print(listtwo)
# 输出：[6, 8]

5）元组：

不可变数据类型

定义：

• （1，）：注意不是（1） == 1 ，int类型
• 空元组的定义：（）——一般不要，因为元组不可变

常用操作：

• 元组.TAB
• 元组.count()：存在元素的数量
• 元组.index()：存在元素的索引

因为元组变量保存的数据类型一般不一致，所以一般不适用循环遍历，即对不同元素采用相同操作。（除非你知道数据类型一致）

应用场景：

• 函数的参数和返回值：一次性接收或是返回多个值
• 格式化字符串：%（）
• 让列表不可以被修改，（将列表转化为元组）以保护数据安全；

list与tuple转换：

• list(元组)
• tuple(列表）

6）集合：

定义：

• set():空集合
• set(iterable)：set(字符串、列表、元组)

7）字典：

定义：{key:value[,key:value……]}

• key必须是唯一的；
• value可以取任何数据类型，key只能是字符串、数字或元组（不可变类型）

操作：

• 取值：
  • dict_name[key] （key不存在会报错）
  • dict_name.get[key] （key不存在会报错）
• 增加/修改：dict_name[key] = value（key存在修改数据，不存在新建键值对）
• 删除：
  • dict_name.pop(key)：删除指定键值对，key不存在会报错
  • dict_name.popitem()：随机删除一个键值对
  • dict_name.clear()：清空字典
  • del dict_name[key]：删除指定键值对，key不存在会报错

基本函数：

• dict_name.keys()：所有key列表
• dict_name.values()：所有value列表
• dict_name.items()：所有(key, value) 元组的列表
• dict_name.setdefault(key, value)：如果key存在，不会修改数据；不存在，新建键值对
• dict_name.update(字典2)：将字典2的数据合并到字典1

遍历：

• for i in dict #i为字段的key
• for i in dict.values()
• for i in dict.items() #i为元组
• for i，j in dict.items() #i，j分别为值

8）字符串

定义：

• 单引号：字符串中如果有“”，
• 双引号

空白字符：

• \r：回车，回行首
• \n：换行
• \t：tab

切片：str[开始索引：结束索引：步长]

• str = [0,1 ,2,3]
• str[: :-1] #[3,2,1,0]
• str[0: : -1] #[0] 从0位开始逆序
• str[-1: :-1] #[3,2,1,0]

元组切片仍是元组

字符串操作：

• 判断
  • len()
  • 字符串.count(小字符串) #小字符串在字符串中的出现的次数
  • str.index(小字符串) #小字符串第一次出现的索引（前提得有）
    
• 查找与替换
  
• 大小写转化
  
  

9）公共方法

• append()：方法参数会被当做一个元素加入列表尾部
• +合并：有新的值产生
• extend()：没有新的值产生

10）完整的for循环

11）enumerate()

将list变为key-value对；

12）isinstance()

isinstance(待测值，目标) #返回T\F

13）assert 语句

assert 语句用以断言（Assert） 某事是真的。

例如说你非常确定你正在使用的列表中至少包含一个元素，并想确认这一点，如果其不是真的，就抛出一个错误， assert 语句就是这种情况下的理想选择。

当语句断言失败时，将会抛出 AssertionError 。

>>> mylist = ['item']
>>> assert len(mylist) >= 1
>>> mylist.pop()
'item'
>>> assert len(mylist) >= 1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AssertionError

你应该明智地选用 assert 语句。在大多数情况下，它好过捕获异常，也好过定位问题或向用户显示错误信息然后退出。

2.linux上的shebang符号（#！）

3.闭包、装饰器、lambda

https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431835236741e42daf5af6514f1a8917b8aaadff31bf000

4.生成器 generator

next()：next(generator)

• 不断迭代生成器，每次到下一个yield
• 直到抛出StopIteration异常

使用 for 迭代：

yield：生成

5.hash()

hash()：

• 接收一个不可变数据类型作为参数：hash(1)
• 返回一个整数：

作用：

• 提取数据的特征码（指纹）
• 即 相同内容—相同结果，不同内容—不同结果

不可变类型：int、str、tuple

可变类型：list、dict

6.类与对象

1.面向对象与面向过程

2.类与对象及：类的设计

类命名的大驼峰命名法：

• 每个单词首字母大写
• 单词单词之间没有下划线

3.面向对象基础语法

4.类实例化对象的引用

5.方法中的self参数

不推荐在类的外部给对象增加属性，因为对象属性的封装应该封装在类的内部；

哪一个对象调用的方法，self就是哪一个对象的引用；

6.初始化方法

类与对象的执行顺序：

• 跳过类定义；
• 实例化对象：使用**类名（）**创建对象
  • 自动为对象分配内存；
  • 自动执行初始化函数，为对象属性设置初始值；
• 对象调用方法：哪一个对象调用的方法，self就是哪一个对象的引用
  • 多个对象的方法，在内存中只有一份；
  • 调用时，需要把对象的引用传递到方法内部；
• 对象在内存中销毁：eg. del 对象名
  • 销毁前，会自动调用 __del__方法

类是一个特殊的对象：（python中一切皆为对象）

• 1）程序运行时，类同样会被加载到内存中
• 2）定义类：class AAA——类对象（可以理解为母版）
• 3）程序运行时，类对象在内存中只有一份
• 4）除了封装的属性与方法外，类对象还拥有自己的属性与方法 ：
  • 类属性
  • 类方法（cls）
• 5)访问类属性、调用类方法：类名.

类属性与实例属性：

• 类名.属性
• self.属性

python中的属性获取机制：向上查找机制——eg.tool1.count

• 1)在对象 tool1 内部查找对象属性；
• 2）没有，则向上，在类属性中寻找；

所以，访问类属性有两种方式：

• 1）类名.类属性
• 2）对象.类属性（不推荐）：
  • 当使用对象.类属性 = 赋值时，只会给对象添加一个属性，而不会影响类属性；

7.内置方法和属性

8.封装：

• 封装是面向对象的一大特点；
• 面向对象编程的 第一步——将 属性 和 方法 封装到一个抽象的类中；
• 外界使用类创建对象，然后让对象调用方法；
• 对象方法的细节都被封装在类的内部

一个对象的属性，可以是另一个类创建的对象：

士兵类的枪属性，可以是枪类的实例

在定义属性时，如果不知道设置什么初始值，可以设置为None
在封装的方法内部，还可以让自己的使用其他类创建的对象属性，调用已经封装好的方法

python中的身份运算符：

• 身份运算符：用于比较两个对象的内存地址是否一致，是否对同一个对象的引用（id()函数查地址）
• is、is not；
• python中针对None的比较，应该使用is
• 与 == 的区别：用于判断引用变量的值是否相等

9.私有属性与私有方法

对象的私有属性： __属性名

• 在外界不能够被直接访问；
• 可以再对象方法内部可以访问对象的私有属性。

对象的私有方法： __方法名（self）

• 在外界不能够被直接访问；

10.继承

方法的重写

11.父类的私有属性与私有方法

12.多继承

这种情况下，同名方法按照类的继承顺序，优先调用前面类的方法。

13.新式类与旧式类

使用 dir(对象) 查看对象的内置属性与方法（包括继承得来的）。

14.多态

15.类的结构

1）类属性

2）类方法

类方法的调用，不需要实例对象，可以直接调用。

3）静态方法

静态方法的调用，不需要实例对象，可以直接调用。

7.单例

单个实例

__new__方法

为对象分配内存空间

**问题：**为什么，子类重写__new__方法时，调用父类的静态方法__new__需要传入cls参数？静态方法不是不需要参数么？？？

8.异常

异常的捕获

错误类型的捕获

捕获未知错误

异常捕获的完整语法

异常的传递

抛出异常

9.函数

1）文档注释：

“”" 文档注释 “”"

查看：快速文档——ctrl+Q

2）返回值：return

• return 表示返回，后续的代码都不会被执行

3）变量的引用：

• 函数传递的是引用（data地址）

4）全局变量与局部变量

python是不允许在函数内部修改全局变量的值（引用）；如果使用赋值语句的话，只是在函数中创建了一个局部变量；

在函数内部修改全局变量的值：

• global关键字：告诉解释器这是一个全局变量
• global num

全局变量一般定义在函数之前，定义名建议：

5）多个参数/返回值：元组

6)注意：函数参数传递的是引用

• 如果参数传递的是可变类型的参数，如果参数在函数内部重新进行了赋值，则理解为局部变量覆盖原始参数——赋值改变了引用；
• 如果可变类型参数进行了修改（不是赋值，如追加）——没有改变引用，则实参也会变化
• 当列表使用+=时：调用的是extend方法，不会修改变量的引用

7)缺省参数：

• 位置必须在函数参数末尾
• 调用多个缺省参数时，需要指定参数名

8)元组和字典的拆包

9)递归

10)函数没有返回值return时：

返回值为 None——使用print(函数)将会输出None

11）dir 函数

内置的 dir() 函数能够返回由对象所定义的名称列表。 如果这一对象是一个模块，则该列
表会包括函数内所定义的函数、类与变量。

该函数接受参数。 如果参数是模块名称，函数将返回这一指定模块的名称列表。 如果没有提供参数，函数将返回当前模块的名称列表。

10.模块

模块的顺序搜索

模块开发原则

1）模块直接提供的代码（模块中没有任何缩进的代码）能够被直接执行，不是为外界提供的工具。

2）文件被导入时，能够直接执行的代码不需要被执行

3）解决办法：__name__属性

__name__属性

在主函数main()：有一系列测试代码

11.包

包的创建、导入、使用

12.发布模块

模块卸载时，模块的安装目录：模块.__file__

13.pip包安装

14.文件操作

.pyc文件：二进制字节码（编译过的）

文件的基本操作

使用with 语句进行文件操作：

在 try 块中获取资源，然后在 finally 块中释放资源是一种常见的模式。因此，还有一个
with 语句使得这一过程可以以一种干净的姿态得以完成。

with open("poem.txt") as f:
	for line in f:
		print(line, end='')

程序输出的内容应与上一个案例所呈现的相同。本例的不同之处在于我们使用的是 open 函数与 with 语句——我们将关闭文件的操作交由 with open 来自动完成。

文件的打开方式

文件复制

小文件复制：

大文件复制：避免一次性读取文件内容带来的内存压力

文件/目录的常用管理操作

15.文本文件的编码

16.eval函数