Python知识速查

文章目录

  • Python概览表
  • 1. Python基础
    • 1.1 认识Python
    • 1.2 注释
    • 1.3 变量
      • 1.3.1 变量名的规范
      • 1.3.2 变量的类型
      • 1.3.3 变量类型转换
    • 1.4 输入(input( ))
    • 1.5 输出(print( ))
      • 1.5.1 格式化输出
    • 1.6 快捷键(小操作)
    • 1.7 运算符
      • 1.7.1 算术运算符
      • 1.7.2 比较运算符
      • 1.7.3 逻辑运算符
      • 1.7.4 成员运算符
      • 1.7.5 身份运算符
  • 2. 流程控制结构
    • 2.1 判断语句
      • 2.1.1 if 结构
      • 2.1.2 if elif else 结构
      • 2.1.3 if else 结构
      • 2.1.4 三元表达式
    • 2.2 循环
      • 2.2.1 for 循环
      • 2.2.2 数据的构建(range)
      • 2.2.2 while 循环
      • 2.2.2 循环终结(continue - break - pass)
  • 3. 数据序列
    • 3.1 字符串(str)
      • 3.1.1 定义
      • 3.1.2 下标
      • 3.1.3 字符串切片
      • 3.1.4 成员方法
    • 3.2 列表(list)
      • 3.2.1 定义
      • 3.2.2 列表切片
      • 3.2.3 成员方法
      • 3.2.4 列表解析 *
      • 3.2.5 嵌套列表浅拷贝和深拷贝
    • 3.3 元组(tuple)
      • 3.3.1 定义
      • 3.3.2 成员方法
      • 3.3.3 枚举(enumerate)
    • 3.4 字典(dict)
      • 3.4.1 定义
      • 3.4.2 成员方法
      • 3.4.3 字典的遍历(3种)
      • 3.4.4 内置函数(zip)
    • 3.5 集合(set)
      • 3.5.1 定义
      • 3.5.2 成员方法
  • 4. 函数
    • 4.1 函数的定义
    • 4.2 函数的参数
      • 4.2.1 默认参数
      • 4.2.2 关键字参数
      • 4.2.3 任意参数(2种)
    • 4.3 闭包函数
      • 4.3.1 定义
      • 4.3.2 语法
    • 4.4 装饰器
      • 4.4.1 定义
      • 4.4.2 语法
    • 4.5 内置函数
      • 4.5.1 map函数(迭代执行)
      • 4.5.2 filter函数(过滤)
    • 4.6 匿名函数(lambda)
      • 4.6.1 定义
      • 4.6.2 语法
  • 5. 面向对象
    • 5.1 面向过程与对象的区别
    • 5.2 类
      • 5.2.1 定义
      • 5.2.2 组成
      • 5.2.3 特性
      • 5.2.4 语法
    • 5.3 魔法方法(内置函数)
      • 5.3.1 __init\_\_ 方法
      • 5.3.2 _\_str__ 方法
      • 5.3.3 _\_del__ 方法
      • 5.3.4 _\_dict__方法
    • 5.4 装饰器
      • 5.4.1 类方法@classmethod
      • 5.4.2 静态方法@staticmethod
    • 5.5 cls 和 self 的区别(知识点)
  • 6. 异常,模块,文件
    • 6.1 异常
      • 6.1.1 语法
    • 6.2 模块
        • 方式一
        • 方式二
        • 方式三 [了解] 基本不用
    • 6.3 文件
      • 6.3.1 文件操作
      • 6.3.2 json 文件的处理
  • 7. Python 进阶知识
    • 7.1 迭代器(Iterator)
    • 7.2 生成器(Yield)


Python概览表

序号 章节 描述
1 Python基础 1.认识Python
2.注释,变量,变量类型,输入输出,运算符
2 流程控制结构 1.判断语句
2.循环
3 数据序列 1.字符串(str)
2.列表(list)
3.元组(tuple)
4.字典(dict)
5.集合(set)
4 函数 1.函数基础
2.变量进阶
3.函数进阶
4.匿名函数
5 面向对象 1.面向对象编程
2.类和对象
3.面向对象基础语法
4.封装,继承,多态
5.类属性和类方法
6 异常,模块,文件 1.异常
2.模块和包
3.文件操作
7 Python进阶知识 1.迭代器(Iterator)
2.生成器(Yield)

1. Python基础

1.1 认识Python

  • Python是一种跨平台的计算机程序设计语言。是一种面向对象的动态类型语言,最初被设计用于编写自动化脚本(shell),随着版本的不断更新和语言新功能的添加,越多被用于独立的、大型项目的开发。

1.2 注释

  • 单行注释
# 这是一个单行注释
# 一般是要空一格开始写。
  • 多行注释
"""双引号多行注释"""
'''单引号多行注释'''
"""一般用于函数中描述"""

1.3 变量

1.3.1 变量名的规范

  1. 变量名只能包含字母,数字和下划线。不能以数字开头。
  2. 变量名不能包含空格,但能使用下划线分隔单词。
  3. 不能将Python关键字和函数名用作变量名。
  4. 变量名应简短且具有描述性。
  5. 慎用小写字母 l 和大写字母 O ,因为它们可能被人看错成数字。

1.3.2 变量的类型

  • 数字类型
类型 变量名 描述
整型 int 1
浮点型 float 1.0
布尔类型 bool True / False
  • 非数字类型
类型 变量名 描述
字符串 str ‘李四’
列表 list [1,2,3]
元组 tuple (1,2,3)
字典 dict {1 : ‘李四’, 2 : ‘张三’}

1.3.3 变量类型转换

类型 方法 描述
整形 int( ) 1.将float类型转为整数型
2.将整数类型的字符串转为整数型
浮点型 float( ) 1.将int类型转为浮点型
2.将数字类型的字符串转为浮点型
字符串 str( ) 将其他类型转换为字符串

1.4 输入(input( ))

# 获取用户使用键盘录入的内容
变量 = input('请输入内容:')

1.5 输出(print( ))

# 将程序中的数据或者结果打印到控制台(屏幕)
print("hello world")

1.5.1 格式化输出

在字符串中指定的位置,输出变量中存储的值。
1.在需要使用变量的地方,使用特殊符号占位。
2.使用变量填充占位的数据。
  • % 格式化输出占位符号
    • %d 占位, 填充 整型数据 digit
    • %f 占位. 填充 浮点型数据 float
    • %f 占位. 填充 字符串数据 str
# 定义变量 姓名  年龄  身高
name = '李四'  
age = 20   
height = 1.75

# 使用格式化输出实现
# print('我的名字是 name, 年龄是 age, 身高是 height m')
print('我的名字是 %s, 年龄是 %d, 身高是 %f m' % (name,age,height))
# 小数默认显示 6 位, 如果想要指定显示小数点后几位,  %.nf , n 需要换成具体的整数数字,即保留小数的位置
  • F-string( f字符串的格式化方法)
f-string 格式化的方法,想要使用 ,Python 的版本 >= 3.6
1. 需要在字符串的前边加上 f"" 或者 F""
2. 占位符号统一变为 {} 
3. 需要填充的变量 写在 {} 中
# 定义变量 姓名  年龄  身高
name = '李四'  
age = 20   
height = 1.75
# 使用 F 格式化输出实现
# print('我的名字是 name, 年龄是 age, 身高是 height m')
print("我的名字是 {name}, 年龄是 {age}, 身高是 {height} m")

1.6 快捷键(小操作)

撤销 : Ctrl Z 
删除一行: Ctrl x
复制粘贴一行: Ctrl d 

1.7 运算符

1.7.1 算术运算符

运算符 描述 实例
+ x + y = 3
- x - y = 1
* x * y = 10
/ x + y = 0.5
// 求商 x // y = 2
% 求余 x % y = 1
** 幂运算,指数运算 x ** 3 = 8

1.7.2 比较运算符

运算符 描述 实例
> 大于 x > 3
< 小于 x < 3
>= 大于等于 x >= 3
<= 小于等于 x <= 3
== 等于 x == 3
!= 不等于 x != 3

1.7.3 逻辑运算符

运算符 描述 实例
and 逻辑与 一假为假
or 逻辑或 一真为真
not 逻辑非 取反

1.7.4 成员运算符

运算符 描述 实例
in 如果在序列中找到值/变量,则为真 5 in list
not in 如果在序列中找到值/变量,则为真 5 not in list

1.7.5 身份运算符

运算符 描述 实例
is 判断俩个变量是否引用同一个地址值,且数值相同 a is b
not is 判断俩个变量是否引用同一个地址值,且数值不相同相同 a not is b

2. 流程控制结构

2.1 判断语句

2.1.1 if 结构

if 判断条件:
    书写条件成立(),执行的代码
    书写条件成立(),执行的代码
print("i like python")

# 顶格书写,没有缩进的代码,和 if 无关, 不管条件是否成立,都会执行

2.1.2 if elif else 结构

if 判断条件1:
    判断条件1成立,执行的代码
elif 判断条件2:  # 只有判断条件1不成立,才会判断 判断条件2
    判断条件2成立执行的代码
else:
    以上条件都不成立,执行的代码

2.1.3 if else 结构

if 判断条件:
    书写条件成立(),执行的代码
    书写条件成立(),执行的代码
else:
    书写条件不成立(), 执行的代码
    书写条件不成立(), 执行的代码

2.1.4 三元表达式

# 语法
结果 if 条件 else 结果
# 例如
c = a if a > b else b

2.2 循环

2.2.1 for 循环

for 变量名 in 容器:
    重复执行的代码

# 1. for 和 in 都是关键字。
# 2. 容器中有多少个数据,循环会执行多少次(0 个数据,执行 0 次, ...)。
# 3. 每次循环,会将容器中数据取出一个保存到 in 关键字前边的变量中。

2.2.2 数据的构建(range)

# 语法: range(start_index,end_index,len)
# start_index: 开始下标; end_index: 结束下标(不包含);len: 步长。
for value in range(,5,2)
	print(value)
    
list_numbers = list(range(1,5,2))
print(list_numbers)

2.2.2 while 循环

index = 0
while index < 5:
    print(index)
    index += 1
# 相当于 Java 中的 for 循环

2.2.2 循环终结(continue - break - pass)

break: 终止循环, 即代码执行遇到 break, 循环不再执行,立即结束。
continue: 跳过本次循环. 即代码执行遇到 continue,本次循环剩下的代码不再执行, 继续下一次循环。
pass: 执行传递时没有任何反应,结果为无操作(NOP)。

3. 数据序列

3.1 字符串(str)

3.1.1 定义

  • 使用引号(单引号, 双引号, 三引号)引起来的内容就是字符串

3.1.2 下标

  • 下标(索引): 就是指字符在字符串中的位置编号, 这个编号就是下标
# 语法: 
str[index]  # 获取指定位置的字符

3.1.3 字符串切片

# 切片: 可以获取字符串中多个字符(多个字符的下标是有规律的, 等差数列)
# 语法:
str[start:end:step] # start:开始位置(从0起步)end:结束位置 step:步长
str[0:2:2]

3.1.4 成员方法

成员方法 描述 实例
find( string, start_index = 0 ) 在字符串中查找“指定字符”。 str.find( ‘lisi’ )
replace( old_str, new_str, count = 全部 ) 替换字符串中的“指定字符”。 str.replace( ‘g’, 'G )
split( string, count = 全部 ) 按照“指定字符”拆分字符串 str.split( ‘,’ )
join( string ) 将字符串和指定字符串链接 ‘-’.join(str)
title() 将字符串的首字母大写 str.title()
upper() 将字符串进行全部大写 str.upper()
lower() 将字符串进行全部小写 str.lower()
strip() 将字符串的空白删除 str.strip()
rstrip() 将字符串的右空白删除 str.rstrip()
lstrip() 将字符串的左空白删除 str.lstrip()

3.2 列表(list)

3.2.1 定义

  • 列表的特点:可重复性,有下标性,可扩展性。

3.2.2 列表切片

# 切片: 可以获取字符串中多个字符(多个字符的下标是有规律的, 等差数列)
# 语法:
list[start:end] # start:开始位置(从0起步)end:结束位置
str[0:5]

3.2.3 成员方法

成员方法 描述 实例
append() 在列表末尾添加一个数据 list.append(‘数据’)
insert(index, 元素) 在列表index下标上添加“指定元素” list.insert(0, ‘元素’)
del list[index] 根据列表下标索引来删除元素 del list[0]
pop(index = -1) 1.把列表末尾的数据抛出
2.根据列表下标索引来抛出元素
1.list.pop()
2.list.pop(0)
remove() 根据“指定元素”删除列表中的值 list.remove(‘元素’)
clear() 清空列表内容 list.clear()
index(‘元素’, start_index,end_index) 查找“指定元素”第一次出现的下标值 list.index(‘元素’)
count(‘元素’) 查找“指定元素”出现的个数 list.count(‘元素’)
copy() 浅克隆一个列表,地址值一样 list.copy()
reverse() 反转列表 list.reverse()
sort(reverse=True) 列表排序 list.sort()
sorted() 列表临时排序,不改变原列表 list.sorted()

3.2.4 列表解析 *

# 语法
运算表达式 循环体 循环后的表达式
# 一
[x**2 for i in range(10)]
# 二
[x**2 for i in range(10) if x % 3 == 0]
# 三
[x**2 for i in range(1,10) for j in range(1,10)]

3.2.5 嵌套列表浅拷贝和深拷贝

  • 拷贝会改变元素地址值

  • 浅拷贝:只拷贝原列表的最外层列表,而内层列表依然指向原列表创建时的内存地址。

成员方法 描述 实例
copy() 浅克隆一个嵌套列表,子对象元素地址值一样。 list.copy()
  • 深拷贝:将外层列表和内层列表同时拷贝。
成员方法 描述 实例
deepcopy() 深克隆一个嵌套列表,元素地址值都不相同。(需要导入copy包) copy.deepcopy()

3.3 元组(tuple)

3.3.1 定义

  • 元组的特点:可重复性,有下标性,数据不可变,不可扩展性。
  • 应用: 在函数的传参或者返回值中使用, 保证数据不会被修改

3.3.2 成员方法

成员方法 描述 实例
index(‘元素’, start_index,end_index) 查找“指定元素”第一次出现的下标值 tuple.index(‘元素’)
count(‘元素’) 查找“指定元素”出现的个数 tuple.count(‘元素’)

3.3.3 枚举(enumerate)

# enumerate( ) 把列表中的每个值转换为元组(0,‘元素’)
lis = ['mon', 'tur', 'sun']
# 遍历
for i in enumerate(lst):
    print(i)

3.4 字典(dict)

3.4.1 定义

  • Python字典是一个无序的项集合。其他复合数据类型只有值作为元素,而字典有一个键:值对(key:value)。

3.4.2 成员方法

成员方法 描述 实例
del dict[key] 根据字典“键值”来删除元素 del dict[‘key’]
pop[key] 根据字典“键值”来抛出元素 dict.pop[‘key’]
clear() 清空字典的键值对 dict.clear()
get(key) 根据“键值“获取字典中对应的值 dict.get[‘key’]

3.4.3 字典的遍历(3种)

# 1. 遍历字典的键
for k in my_dict.keys():
    print(k)

# 2. 遍历字典的值
for v in my_dict.values():
    print(v)

# 3. 遍历键值
for k, v in my_dict.items():
    print(k, v)

3.4.4 内置函数(zip)

# zip( ) 函数用于把俩个列表组合起来转换为字典
lis1 = ['name','age','day']
lis2 = ['lisi', 12 , 30]
# 第一种方法
for i in zip(lis1,lis2):
    print(f"{i}")
# 第二种方法
lis = list(zip(lis1,lis2))
print(lis)

3.5 集合(set)

3.5.1 定义

  • 集合是项目的无序集合。每个元素都是唯一的(没有重复项),只能增加或删除元素(不能更改元素)。

3.5.2 成员方法

成员方法 描述 实例
add(元素) 在集合末尾添加一个数据 set.add(元素)
remove(元素) 根据“指定元素”删除集合中的值 set.remove(‘元素’)
交集 & 集合相交 set1 & set2
并集 | 集合并集 set1 | set2
差集 - 集合相差 set1 - set2

4. 函数

4.1 函数的定义

  • 函数是一组执行特定任务的相关语句。
def function_name(parameters):
	"""docstring"""
	print(parameters)
    return parameters

4.2 函数的参数

4.2.1 默认参数

def greet(name, msg="早上好!"):
    """
    此函数向提供消息的人打招呼。
    如果没有提供消息,
    则默认为“早上好!”
    """
    print("你好", name + ', ' + msg)

4.2.2 关键字参数

def greet(name, msg):
    print("你好", name + ', ' + msg)
    
greet(name='lisi',msg='你好啊!')
greet(msg='你好啊!',name='lisi')
greet('lisi',msg='你好啊!')

4.2.3 任意参数(2种)

  • 不定长元组参数
# 不定长元组参数
def greet(*args):l;kl  
    """此函数被打招呼的对象为
        元组列表中的所有人."""
    for arg in args:
        print("Hello", arg)
# 名称是一个带有参数的元组
greet("Monica", "Luke", "Steve", "John")
greet(*("Monica", "Luke", "Steve", "John"))
  • 不定长字典参数
# 不定长字典参数
def greet(**kwargs):
    """此函数被打招呼的对象为
        元组列表中的所有人."""
    for key in kwargs.keys():
        print(kwargs[key])
# 名称是一个带有参数的字典
greet(a=1, b=2, c=3)
greet(a=1, b=2, c=3)

4.3 闭包函数

4.3.1 定义

  • 闭包函数是指一个函数内部定义的函数,并且内部函数可以访问外部函数的局部变量或者参数。在Python中,函数是一等对象,因此我们可以将函数作为返回值返回,这样就创建了一个闭包函数。

4.3.2 语法

# 闭包函数
def outer_func(*args):
    print(f"this is args: {args}")
    def inner_func(**kwargs):
        print(f"this is kwargs: {kwargs}")
        print(f"this is outer_func de args:{args}")
    return inner_func
a = outer_func(*(1,2,3,4,5,6,7,8))
print("this is inner:",a(**{"name": "lisan", "age" : 18}))
# 结果
this is args: (1, 2, 3, 4, 5, 6, 7, 8)
this is kwargs: {'name': 'lisan', 'age': 18}
this is outer_func de args:(1, 2, 3, 4, 5, 6, 7, 8)
this is inner: None

4.4 装饰器

4.4.1 定义

  • 装饰器是利用了函数的这些特性(函数是一等对象、闭包和语法糖),实现在不修改被装饰函数源代码的情况下,向函数添加额外功能的一种方式。
  • 装饰器本质上是一个函数,它接受一个函数作为输入,并返回一个新的函数,这个新函数通常会包装原始函数并添加额外的功能。

4.4.2 语法

# 装饰器(给函数附加功能)
def decorator(func):
    def cost_time(*args):
        start_time = time.time()
        func(args[0], args[1])
        end_time = time.time()
        print(f"cost time is : {end_time - start_time}")
    return cost_time

@decorator
def user_add(username, password):
    print(f"username: {username} and password: {password}")
    time.sleep(1)

user_add("lisi", 123456)
# 结果
username: lisi and password: 123456
cost time is : 19.870102167129517

4.5 内置函数

4.5.1 map函数(迭代执行)

# 格式
map(func,*args)
# 举例
map(lamdba x : x + 3,range(1,10))

4.5.2 filter函数(过滤)

# 格式
filter(func,*args)
# 举例
filter(lamdba x : x > 0,range(-3,3))

4.6 匿名函数(lambda)

4.6.1 定义

匿名函数: 就是使用 lambda 关键字定义的函数

匿名函数只能书写一行代码。
匿名函数的返回值不需要 return, 一行代码(表达式) 的结果就是返回值。

使用场景: 作为函数的参数, 这个函数比较简单,值使用一次,没有必要使用 def 定义。

4.6.2 语法

lambda 参数: 一行代码   # 这一行代码,称为是表达式

# 匿名函数一般不需要我们主动的调用, 一般作为函数的参数使用的
# 我们在学习阶段为了查看匿名函数定义的是否正确,可以调用
# 1, 在定义的时候 ,将匿名函数的引用保存到一个变量中
变量 = lambda 参数: 一行代码
fun = lambda x : print(x,'Hello')
# 调用lambda函数
fun(9)

5. 面向对象

5.1 面向过程与对象的区别

  • 面向过程
    • 关注的是 具体步骤的实现, 所有的功能都自己书写
    • 亲力亲为
    • 定义一个个函数, 最终按照顺序调用函数
  • 面向对象
    • 关注的是结果, 谁(对象) 能帮我做这件事
    • 偷懒
    • 找一个对象(), 让对象去做

5.2 类

5.2.1 定义

  • 抽象的概念, 对 多个 特征和行为相同或者相似事物的统称
  • 泛指的(指代多个,而不是具体的一个)

5.2.2 组成

  1. 类名 (给这多个事物起一个名字, 在代码中 满足大驼峰命名法(每个单词的首字母大写))
  2. 属性 (事物的特征, 即有什么, 一般文字中的名词)
  3. 方法 (事物的行为, 即做什么事, 一般是动词)

5.2.3 特性

  • 封装

封装是指将属性操作方法打包在一起,形成一个称为类的实体。
类通过公共接口提供对其内部实现细节的访问。
通过封装,我们可以隐藏具体实现的细节,只暴露必要的接口给外部使用。使用关键字class定义一个类来实现封装。

class Animal:
    """动物类"""
    def __init__(self, name, age, fly):
        self.name = name
        self.age = age
        self.__fly = fly

    def eat(self, food):
        print(f"{self.name} is eating {food}")

    def __era(self):
        print(f"{self.name} 是私有方法!")
  • 继承

继承是指使用一个已经存在的类作为基础,从而创建一个新类。
新类可以继承原有类的属性和方法,并可以添加自己特定的属性和方法。
继承提供了重用代码的方式,子类可以重写父类的方法或者添加新的方法。使用关键字class后面跟上父类名称,实现继承。

class Fish(Animal):
    """鱼类"""
    def __init__(self, name, age, color):
        super().__init__(name, age, fly="None")
        self.color = color

    def show(self):
        print(f"{self.name} is showing")
  • 多态

多态是指在不同的对象上执行相同的操作时,可以根据对象的类型执行不同的操作。
多态允许使用一致的方式处理不同类型的对象

5.2.4 语法

class 类名:
    """定义添加属性的方法"""
    def __init__(self, name, age):  # 这个方法是创建对象之后调用
        self.name = name  # 给对象添加 name 属性
        self.age = age   # 给对象添加 age 属性
        
    """在缩进中书写的内容,都是类中的代码"""
    def 方法名(self):   # 就是一个方法
        pass 

5.3 魔法方法(内置函数)

5.3.1 __init__ 方法

1. 什么情况下自动调用
    > 创建对象之后会自动调用
2. 有什么用, 用在哪
    > 1. 给对象添加属性的, (初始化方法, 构造方法)   2. 某些代码, 在每次创建对象之后, 都要执行,就可以将这行代码写在 __init__ 方法
3. 书写的注意事项
    > 1. 不要写错了   2. 如果 init 方法中,存在出了 self 之外的参数, 在创建对象的时候必须传参
class Cat:
    # 定义添加属性的方法
    def __init__(self, name, age):  # 这个方法是创建对象之后调用
        self.name = name  # 给对象添加 name 属性
        self.age = age   # 给对象添加 age 属性

5.3.2 _str_ 方法

1. 什么情况下自动调用
    > 使用 print(对象) 打印对象的时候 会自动调用
2. 有什么用, 用在哪
    > 在这个方法中一般书写对象的 属性信息的, 即打印对象的时候想要查看什么信息,在这个方法中进行定义的
    > 如果类中没有定义 __str__ 方法,  print(对象) ,默认输出对象的引用地址
3. 书写的注意事项
    > 这个方法必须返回 一个字符串
class Cat:
    # 定义添加属性的方法
    def __init__(self, n, age):  # 这个方法是创建对象之后调用
        self.name = n  # 给对象添加 name 属性
        self.age = age   # 给对象添加 age 属性def __str__(self):
        # 方法必须返回一个字符串, 只要是字符串就行,
        return f'小猫的名字是: {self.name}, 年龄是: {self.age}'

5.3.3 _del_ 方法

__init__ 方法, 创建对象之后,会自动调用  (构造方法)
__del__ 方法, 对象被删除销毁时, 自动调用的(遗言, 处理后事)  (析构方法)
​
1. 调用场景, 程序代码运行结束, 所有对象都被销毁
2. 调用场景, 直接使用 del 删除对象(如果对象有多个名字(多个对象引用一个对象),需要吧所有的对象都删除才行 )
class Demo:
    def __init__(self, name):
        print('我是 __init__, 我被调用了 ')
        self.name = name
​
    def __del__(self):
        print(f'{self.name} 没了, 给他处理后事...')

5.3.4 __dict__方法

__dict__ 方法,查看实例化对象的所有属性
class Demo:
    def __init__(self, name, age, grade):
        self.name = name
        self.age = age
        self.grade = grade
        
d1 = Demo('lisan', 12, 1)
print(d1.__dict__) # 展示d1的所有属性

5.4 装饰器

5.4.1 类方法@classmethod

class Demo:
    @classmethod
    dfe met(cls) # cls -> 类本身
    	print(cls)
        
Demo.met()
# 结果
<class '__main__.Work'>

5.4.2 静态方法@staticmethod

class Demo:
    @staticmethod
    def method():
        return 1
    
print('Data is :', Demo.metod())

5.5 cls 和 self 的区别(知识点)

cls和self的区别?
答:cls是类本身的引用,例如:。
self是类实例化对象的引用,例如:<__main__.Work object at 0x0000013B1BFCF3D0>
Student # Student -> 是cls的引用
s1 = Student() # s1 -> 是Student的实例化对象,s1-> self

6. 异常,模块,文件

6.1 异常

6.1.1 语法

try:
    可能发生异常的代码
except 异常类型1:
    发生异常类型1执行的代码  
except Exception as 变量:  
    发生其他类型的异常,执行的代码
    # Exception是常见异常类的父类。Exception,可以捕获常见的所有异常, as 变量, 这个变量是一个异常类的对象, print(变量) 可以打印异常信息 
else:
    没有发生异常会执行的代码
finally: 
    不管有没有发生异常,都会执行的代码xxxxxxxxxx

6.2 模块

  • 方式一

import 模块名
# 使用模块中的内容
模块名.工具名
  • 方式二

from 模块名 import 工具名
# 使用
工具名  # 如果是函数和类需要加括号
  • 方式三 [了解] 基本不用

from 模块名 import *  
# 将模块中所有的内容都导入

6.3 文件

6.3.1 文件操作

  • 方法一
# 1.打开文件
file_name = 'a.txt'
file = open(file_name, 'w', encoding='utf-8')
"""
参数 mode:  默认参数(r参数), 表示的是打开文件的方式 
        > r: read 只读打开
        > w: write  只写打开
        > a> append 追加打开, 在文件的末尾写入内容
"""
# 2.读文件
file.read()
file.readline()
# 3.写文件
file.write('好好学习\n')
# 4.关闭文件
file.close()
  • 方法二
with open() 打开文件的好处: 不用自己去书写关闭文件的代码, 会自动进行关闭
file_name = 'a.txt'
with open(file_name, 'r' , encoding='utf-8') as file:
    while True:
        buf = file.readline()
        if buf:  # if len(buf) != 0
            print(buf)
        else:
            break

6.3.2 json 文件的处理

  • json文件的读取
# 1, 导入 json
import json

# 2, 读打开文件
file_name = 'info.json'
with open(file_name, encoding='utf-8') as f:
    # 3. 读取文件
    result = json.load(f)
  • json文件的写入
# 1, 导入 json
import json

# 2, 读打开文件
file_name = 'info.json'
data = {
    "name": "Tom",
    "age": 20,
    "city": "New York"
}
with open(file_name, 'w' ,encoding='utf-8') as f:
    # 3. 读取文件
    result = json.dump(my_list, f, ensure_ascii=False, indent=4)
    
# ensure_ascii: 默认值为True,如果该选项为True,则所有非 ASCII 字符将转换成 Unicode 转义序列.
# indent: 如果指定了该参数,则使用指定的缩进间隔,使得输出更加易读.

7. Python 进阶知识

7.1 迭代器(Iterator)

迭代器是可以迭代的对象。
从技术上讲,Python 迭代器对象必须实现两个特殊方法,iter()和__next__()统称为迭代器协议

lis = [1, 2, 3, 4]
lis_iter = iter(lis)
lis_iter.__next__() # 此操作会使得迭代索引➕1
for i in lis_iter:
    print(i)

7.2 生成器(Yield)

Python生成器是创建迭代器的简单方法。我们上面提到的所有开销都由Python的生成器自动处理。
生成器是一个函数,它返回一个对象(迭代器),我们可以对其进行迭代(一次一个值)。

def demo_yield(n):
    print('start')
    while n > 0:
        print('yiekd before')
        yield n				# 程序执行开始挂起,返回n值
        n -= 1
        print('after yield')
        
y = demo_yield(3)
print(y.__next__())	# 第一次调用
print(y.__next__())	# 第二次调用
print(y.__next__())	# 第三次调用
print(y.__next__())	# 超出调用

你可能感兴趣的:(Python,python)