Python 学习笔记

明明明h2024-03-21 16:01

文章目录

  • 0.常用
  • 1.环境搭建
  • 2.VSCode运行Python脚本
  • 3.基础语法
    • [3.1 注释](#3.1 注释)
    • [3.2 多行语句](#3.2 多行语句)
    • [3.3 print 输出](#3.3 print 输出)
    • [3.4 import 导入](#3.4 import 导入)
  • 4.基本数据类型
    • [4.1 类型判断](#4.1 类型判断)
    • [4.2 Number（数字）](#4.2 Number（数字）)
      • [4.2.1 int](#4.2.1 int)
      • [4.2.2 float](#4.2.2 float)
      • [4.2.3 bool](#4.2.3 bool)
      • [4.2.4 complex（复数）](#4.2.4 complex（复数）)
    • [4.3 String（字符串）](#4.3 String（字符串）)
    • [4.4 list （列表）](#4.4 list （列表）)
    • [4.5 tuple （元组）](#4.5 tuple （元组）)
    • [4.6 dict （字典）](#4.6 dict （字典）)
    • [4.7 set （集合）](#4.7 set （集合）)
  • 5.数据类型转换
  • 6.运算符
    • [5.1 算术运算符](#5.1 算术运算符)
    • [5.2 比较运算符](#5.2 比较运算符)
    • [5.3 赋值运算符](#5.3 赋值运算符)
      • [5.3.1 海象运算符](#5.3.1 海象运算符)
    • [5.4 位运算符](#5.4 位运算符)
    • [5.5 逻辑运算符](#5.5 逻辑运算符)
    • [5.6 成员运算符 in](#5.6 成员运算符 in)
    • [5.7 身份运算符 is](#5.7 身份运算符 is)
    • [5.8 is 与 == 区别](#5.8 is 与 == 区别)
  • [7. 函数](#7. 函数)
    • [7.1 数学函数](#7.1 数学函数)
    • [7.2 随机函数](#7.2 随机函数)
    • [7.3 三角函数](#7.3 三角函数)
    • [7.4 数学常量](#7.4 数学常量)
  • 8.条件控制
    • [8.1 if...elif...else](#8.1 if...elif...else)
    • [8.2 match...case](#8.2 match...case)
  • 9.循环语句
    • [9.1 while...else](#9.1 while...else)
    • [9.2 for](#9.2 for)
    • [9.3 for...else](#9.3 for...else)
    • [9.4 pass](#9.4 pass)
  • 10.推导式
    • [10.1 列表推导式](#10.1 列表推导式)
    • [10.2 字典推导式](#10.2 字典推导式)
    • [10.3 集合推导式](#10.3 集合推导式)
    • [10.4 元组推导式](#10.4 元组推导式)
  • 11.迭代器和生成器
    • [11.1 迭代器 iter](#11.1 迭代器 iter)
    • [11.2 生成器 generator](#11.2 生成器 generator)
  • 12.函数
    • [12.1 可更改(mutable)与不可更改(immutable)对象:](#12.1 可更改(mutable)与不可更改(immutable)对象:)
    • [12.2 参数](#12.2 参数)
    • [12.3 lambda 表达式](#12.3 lambda 表达式)
  • 13.模块
    • [13.1 \_\name\\_属性](#13.1 __name__属性)
    • [13.2 dir()](#13.2 dir())
  • 14.输入和输出
    • [14.1 读取键盘输入](#14.1 读取键盘输入)
  • 15.文件/目录操作
    • [15.1 文件操作](#15.1 文件操作)
    • [15.2 目录操作](#15.2 目录操作)
  • [16 序列化与反序列化](#16 序列化与反序列化)
    • [16.1 序列化（dump，dumps）](#16.1 序列化（dump，dumps）)
    • [16.2 反序列化（load，loads）](#16.2 反序列化（load，loads）)
  • 17.错误和异常
    • [17.1 抛出异常 raise](#17.1 抛出异常 raise)
    • [17.2 断言 assert](#17.2 断言 assert)
    • [17.3 with 关键字](#17.3 with 关键字)
  • 18.面向对象
    • [18.1 类](#18.1 类)
    • [18.2 类属性和方法](#18.2 类属性和方法)
    • [18.3 类的专有方法](#18.3 类的专有方法)
    • [18.4 继承](#18.4 继承)
    • [18.5 多继承](#18.5 多继承)
    • [18.6 方法重写](#18.6 方法重写)
  • 19.作用域
    • [19.1 特殊情况](#19.1 特殊情况)

0.常用

  • 输出

    python 复制代码 
    # 不换行输出
print('hello world', '')

# 带参数输出
name = 'ming'
print('hello {0}'.format(name))

  • 截取

    python 复制代码 
    变量[头下标:尾下标:步长]
list[0:] # 从头到尾

  • range()

    python 复制代码 
    range(5) # [0, 1, 2, 3, 4]
range(5, 9) # [5, 6, 7, 8]
range(5, 9, 2) # [5, 7]

  • 遍历技巧

    • 在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

      pytHon 复制代码 
      dic = {'key1': 'value1', 'key2': 'value2'}
for k, v in dic.items():
    print(k, v)

'''
key1 value1
key2 value2
'''

    • 在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

      python 复制代码 
      for i, v in enumerate(['apple', 'banana', 'pear']):
    print(i, v)

'''
0 apple
1 banana
2 pear
'''

    • 同时遍历两个或更多的序列，可以使用 zip() 组合：

      python 复制代码 
      questions = ['name', 'sex', 'favorite color']
answers = ['Bob', 'mboy', 'blue']

for q, a in zip(questions, answers):
    print('What is your {0}? It is {1}.'.format(q, a))
    
'''
What is your name? It is Bob.
What is your sex? It is mboy.
What is your favorite color? It is blue.
'''

    • 要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：

      python 复制代码 
      >>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

1.环境搭建

参考菜鸟教程配置：Python3 环境搭建 | 菜鸟教程 (runoob.com)

运行脚本：

cmd 复制代码 
python script.py

2.VSCode运行Python脚本

使用vscode编写、运行Python程序_vscode写python-CSDN博客

3.基础语法

3.1 注释

python 复制代码 
# 第一个注释
# 第二个注释
 
'''
第三注释
第四注释
'''
 
"""
第五注释
第六注释
"""
print ("Hello, Python!")

3.2 多行语句

python 复制代码 
total = item_one + \
        item_two + \
        item_three

3.3 print 输出

python 复制代码 
# 换行输出
print(x)
# 不换行输出
print(x, end="")

3.4 import 导入

python 复制代码 
# 将整个模块(somemodule)导入
import somemodule
# 从某个模块中导入某个函数
from somemodule import somefunction
# 从某个模块中导入多个函数
from somemodule import firstfunc, secondfunc, thirdfunc
# 将某个模块中的全部函数导入
from somemodule import *

4.基本数据类型

  • **不可变数据（3 个）：**Number（数字）、String（字符串）、Tuple（元组）；
  • **可变数据（3 个）：**List（列表）、Dictionary（字典）、Set（集合）。

4.1 类型判断

  • type()不会认为子类是一种父类类型。
  • isinstance()会认为子类是一种父类类型。

4.2 Number（数字）

4.2.1 int

4.2.2 float

4.2.3 bool

bool 是 int 的子类，True 和 False 可以和数字相加，True==1、False == 0

0、空字符串、空列表、空元组 等被视为 False

4.2.4 complex（复数）

4.3 String（字符串）

  1. 字符串截取：

    python 复制代码 
    # 包含头，不包含尾
变量[头下标:尾下标:步长]
    python 复制代码 
    # 加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数
str = 'Runoob'

print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串

'''
Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST
'''

    1. 转义字符

      python 复制代码 
      # python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串
>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>

4.4 list （列表）

  • 基本操作
python 复制代码 
list = [1, "red", "blue", 3, "yellow"]
print(list[0])
print(list[-2])
print(list[0: -1: 2])

'''
1
3
[1, 'blue']
'''

  • 脚本操作符

    列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

    python 复制代码 
    L1 = [1, 2, 3]
L2 = [4, 5, 6]
print(L1 + L2)
print(L1 * 3)

'''
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 1, 2, 3, 1, 2, 3]
'''

  • 列表嵌套

    python 复制代码 
    list = [['a', 'b', 'c'], [1, 2, 3]]
print(list[1][0])

# 1

  • 列表比较

    python 复制代码 
    import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))

'''
False
True
'''

  • 列表函数&方法

    Python包含以下函数:

    序号 函数
    1 len(list) 列表元素个数
    2 max(list) 返回列表元素最大值
    3 min(list) 返回列表元素最小值
    4 list(seq) 将元组转换为列表

    Python包含以下方法:

    方法 描述
    list.append(x) 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
    list.extend(L) 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
    list.insert(i, x) 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
    list.remove(x) 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
    list.pop([i]) 从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
    list.clear() 移除列表中的所有项，等于del a[:]。
    list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
    list.count(x) 返回 x 在列表中出现的次数。
    list.sort() 对列表中的元素进行排序。
    list.reverse() 倒排列表中的元素。
    list.copy() 返回列表的浅复制，等于a[:]。

4.5 tuple （元组）

特点：元组中的元素不能修改

python 复制代码 
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d" #  不需要括号也可以
print(type(tup3))
<class 'tuple'>

# 元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：
tup1 = (50)
print(type(tup1))     # 不加逗号，类型为整型 <class 'int'>

tup1 = (50,)
print(type(tup1))     # 加上逗号，类型为元组 <class 'tuple'>

4.6 dict （字典）

python 复制代码 
dic = {'Name': 'Ming', 'Age': 7, 'Class': 'First'}
print(dic['Name'])

# 更新
dic['Age'] = 18
# 添加
dic['School'] = "菜鸟教程"

print(type(dic))

  • 字典内置函数&方法

  • Python字典包含了以下内置函数：

    序号 函数及描述 实例
    1 len(dict) 计算字典元素个数，即键的总数。 >>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(tinydict) 3
    2 str(dict) 输出字典，可以打印的字符串表示。 >>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(tinydict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
    3 type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 >>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(tinydict) <class 'dict'>

    Python字典包含了以下内置方法：

    序号 函数及描述
    1 dict.clear() 删除字典内所有元素
    2 dict.copy() 返回一个字典的浅复制
    3 dict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
    4 dict.get(key, default=None) 返回指定键的值，如果键不在字典中返回 default 设置的默认值
    5 key in dict 如果键在字典dict里返回true，否则返回false
    6 dict.items() 以列表返回一个视图对象
    7 dict.keys() 返回一个视图对象
    8 dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
    9 dict.update(dict2) 把字典dict2的键/值对更新到dict里
    10 dict.values() 返回一个视图对象
    11 [pop(key,default]) 删除字典 key（键）所对应的值，返回被删除的值。
    12 popitem() 返回并删除字典中的最后一对键和值。

4.7 set （集合）

​ 集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

python 复制代码 
# 创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
emptySet = set()
print(type(emptySet))

# 直接使用大括号创建集合
set1 = {1, 2, 3, 4}         
# 使用 set() 函数从列表创建集合  
set2 = set([4, 5, 6, 7])

  • 集合基本操作

    python 复制代码 
    set3 = { 'apple', 'watermelon', 'pear', }
# 添加元素
set3.add('banana')
print(set3)     # {'pear', 'watermelon', 'banana', 'apple'}
set3.update(set([1, 2]))
print(set3)     # {'pear', 1, 2, 'apple', 'watermelon', 'banana'}
# 移除元素
set3.remove('apple')
print(set3)
# 随机移除元素
print('随机移除的元素: ', '')
print(set3.pop())
print('随机移除后的集合：', '')
print(set3)

5.数据类型转换

函数 描述
[int(x ,base]) 将x转换为一个整数
float(x) 将x转换到一个浮点数
[complex(real ,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

6.运算符

5.1 算术运算符

以下假设变量 a=10 ，变量 b=21：

运算符 描述 实例
+ 加 - 两个对象相加 a + b 输出结果 31
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -11
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 210
/ 除 - x 除以 y b / a 输出结果 2.1
% 取模 - 返回除法的余数 b % a 输出结果 1
** 幂 - 返回x的y次幂 a**b 为10的21次方
// 取整除 - 往小的方向取整数 >>> 9//2 4 >>> -9//2 -5

5.2 比较运算符

以下假设变量 a 为 10，变量 b 为20：

运算符 描述 实例
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 True。
> 大于 - 返回x是否大于y (a > b) 返回 False。
< 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 (a < b) 返回 True。
>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 True。

5.3 赋值运算符

以下假设变量a为10，变量b为20：

运算符 描述 实例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
//= 取整除赋值运算符 c //= a 等效于 c = c // a
:= 海象运算符，这个运算符的主要目的是在表达式中同时进行赋值和返回赋值的值。Python3.8 版本新增运算符。

5.3.1 海象运算符

python 复制代码 
# 传统写法
n = 10
if n > 5:
    print(n)
    
# 使用海象运算符
if (n := 10) > 5:
    print(n)
    
# n 次循环的一般写法：    
n = 5
while n:
    print('hello, walrus operator!')
    n -= 1
    
# n 次循环使用海象运算符:
n = 5
while (n := n - 1) + 1: # 需要加1是因为执行输出前n就减1了
    print('hello, walrus operator!')

5.4 位运算符

下表中变量 a 为 60，b 为 13二进制格式如下：

python 复制代码 
a = 0011 1100
b = 0000 1101
-----------------

a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a  = 1100 0011
运算符 描述 实例
& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101
^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<< 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000
>> 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111

5.5 逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符 逻辑表达式 描述 实例
and x and y 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False

5.6 成员运算符 in

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
python 复制代码 
a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
 
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

'''
1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中
'''

5.7 身份运算符 is

身份运算符用于比较两个对象的存储单元

运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y , 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注： id() 函数用于获取对象内存地址。

python 复制代码 
a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")
 
if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")

'''
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识
'''

5.8 is 与 == 区别

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

python 复制代码 
>>>a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True

7. 函数

7.1 数学函数

函数 返回值 ( 描述 )
abs(x) 返回数字的绝对值，如abs(-10) 返回 10
ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换。
exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x) 以浮点数形式返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。
min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。
modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y) x**y 运算后的值。
[round(x ,n]) 返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。
sqrt(x) 返回数字x的平方根。

7.2 随机函数

函数 描述
choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
[randrange (start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random() 随机生成下一个实数，它在[0,1)范围内。
[seed(x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst) 将序列的所有元素随机排序
uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。

7.3 三角函数

函数 描述
acos(x) 返回x的反余弦弧度值。
asin(x) 返回x的反正弦弧度值。
atan(x) 返回x的反正切弧度值。
atan2(y, x) 返回给定的 X 及 Y 坐标值的反正切值。
cos(x) 返回x的弧度的余弦值。
hypot(x, y) 返回欧几里德范数 sqrt(xx + yy)。
sin(x) 返回的x弧度的正弦值。
tan(x) 返回x弧度的正切值。
degrees(x) 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x) 将角度转换为弧度

7.4 数学常量

常量 描述
pi 数学常量 pi（圆周率，一般以π来表示）
e 数学常量 e，e即自然常数（自然常数）

8.条件控制

8.1 if...elif...else

python 复制代码 
age = int(input("请输入你家狗狗的年龄: "))
print("")
if age <= 0:
    print("你是在逗我吧!")
elif age == 1:
    print("相当于 14 岁的人。")
elif age == 2:
    print("相当于 22 岁的人。")
elif age > 2:
    human = 22 + (age -2)*5
    print("对应人类年龄: ", human)
 
### 退出提示
input("点击 enter 键退出")

8.2 match...case

python 复制代码 
# switch...case
def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"

mystatus=400
print(http_error(400))

9.循环语句

9.1 while...else

python 复制代码 
while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>

9.2 for

python 复制代码 
for <variable> in <sequence>:
    <statements>
else:
    <statements>

9.3 for...else

for...else 语句用于在循环结束后执行一段代码

python 复制代码 
for item in iterable:
    # 循环主体
else:
    # 循环结束后执行的代码

9.4 pass

pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句.

10.推导式

推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体

10.1 列表推导式

python 复制代码 
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]
python 复制代码 
# 计算 30 以内可以被 3 整除的整数:
multiples = [i for i in range(30) if i % 3 == 0]
print(multiples, end='\n\n')

# 过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：
names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
new_names = [name.upper() for name in names if len(name) > 3]
print(new_names, '\n\n')

10.2 字典推导式

python 复制代码 
{ key_expr: value_expr for value in collection if condition }
python 复制代码 
# 使用字符串及其长度创建字典：
listdemo = ['Google','Runoob', 'Taobao']
newdict = {key:len(key) for key in listdemo}
print(newdict)

10.3 集合推导式

python 复制代码 
{ expression for item in Sequence if conditional }
python 复制代码 
# 判断不是 abc 的字母并输出：
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a, type(a), '\n\n')

10.4 元组推导式

  • 元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。
  • 元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 [ ] ，另外元组推导式返回的结果是一个生成器对象。
python 复制代码 
(expression for item in Sequence if conditional )
python 复制代码 
a = (x for x in range(1, 10))
print(a, type(a))   # <generator object <genexpr> at 0x0000024B70D5F1D0> <class 'generator'>
print(tuple(a))     # (1, 2, 3, 4, 5, 6, 7, 8, 9)

11.迭代器和生成器

11.1 迭代器 iter

迭代器有两个基本的方法：iter()和next()

python 复制代码 
import sys         # 引入 sys 模块
 
list=[1, 2, 3, 4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print(next(it))
    except StopIteration:
        sys.exit()

创建一个迭代器：

  • iter()：返回一个特殊的迭代器对象， 这个迭代器对象实现了__next__() 方法并通过 StopIteration 异常标识迭代的完成

  • next()：返回下一个迭代器对象

  • StopIteration：用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代

python 复制代码 
class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
  print(x)

11.2 生成器 generator

使用了 yield 的函数被称为生成器（generator）

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

python 复制代码 
def countdown(n):
    while n > 0:
        yield n
        n -= 1
 
# 创建生成器对象
generator = countdown(5)
 
# 通过迭代生成器获取值
print(next(generator))  # 输出: 5
print(next(generator))  # 输出: 4
print(next(generator))  # 输出: 3
 
# 使用 for 循环迭代生成器
for value in generator:
    print(value)  # 输出: 2 1

12.函数

python 复制代码 
def 函数名（参数列表）:
函数体

函数的第一行语句可以选择性地使用文档字符串---用于存放函数说明。

12.1 可更改(mutable)与不可更改(immutable)对象:

  • 不可变类型：strings, tuples, numbers

    如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。

  • 可变类型：list, dict

    如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

python 复制代码 
# 函数传递不可变对象
def change(a):
    print(id(a))     # 指向的是同一个对象
    a = 10
    print(id(a))     # 一个新对象

a = 1
print(id(a))
change(a)

'''
140733829894952
140733829894952
140733829895240
'''

# 函数传递可变对象
def changeme(mylist):
    print(id(mylist))
    mylist.append([4, 5, 6])
    print(id(mylist))

mylist = [1, 2, 3]
print(id(mylist))
changeme(mylist)

'''
1758081367872
1758081367872
1758081367872
'''

12.2 参数

  1. 默认参数

    python 复制代码 
    def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

  2. 关键字参数

    python 复制代码 
    def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )

  3. 不定长参数
    加了星号 ***** 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数

    python 复制代码 
    def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
    python 复制代码 
    def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

    加了两个星号 ****** 的参数会以字典的形式导入

    python 复制代码 
    def functionname([formal_args,] **var_args_dict ):
"函数_文档字符串"
function_suite
return [expression]
    python 复制代码 
    def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

'''
1
{'a': 2, 'b': 3}
'''

  4. 强制位置参数
    /： / 前面的形参必须使用指定位置参数，不能使用关键字参数的形式
    ， 后的参数必须用关键字传入

    python 复制代码 
    def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
 
# 正确使用
f(10, 20, 30, d=40, e=50, f=60)

12.3 lambda 表达式

python 复制代码 
lambda [arg1 [,arg2,.....argn]]:expression
python 复制代码 
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

13.模块

  • 搜索路径
    sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表

    python 复制代码 
    import sys

print(sys.path)
# 'd:\\学习\\PythonLearn\\脚本', 'D:\\Software\\Python\\python311.zip', 'D:\\Software\\Python\\DLLs', 'D:\\Software\\Python\\Lib', 'D:\\Software\\Python', 'D:\\Software\\Python\\Lib\\site-packages']

  • 导入模块

    python 复制代码 
    import module1[, module2[,... moduleN]

    support.py

    python 复制代码 
    def log( par ):
    print ("logFun : ", par)
    return

def log1( par ):
    print ("log1Fun : ", par)
    return

  • import

    python 复制代码 
    # import导入
import support

support.log('import导入')
support.log1('import导入')

  • from...import
    从模块中导入一个指定的部分到当前命名空间中

    python 复制代码 
    # from...import导入
from support import log, log1

log('from...import导入')
log1('from...import导入')

  • **from...import ***
    把一个模块的所有内容全都导入到当前的命名空间

    python 复制代码 
    # from...import* 导入
from support import*

log('from...import* 导入')
log1('from...import* 导入')

13.1 __name__属性

每个模块都有一个__name__属性，当其值是'main'时，表明该模块自身在运行，否则是被引入

support.py

python 复制代码 
if __name__ == '__main__':
    print('程序自身在运行')
else:
    print('程序被另一模块引用')

运行该脚本：

python 复制代码 
程序自身在运行

test.py

python 复制代码 
import support

# 运行输出：程序被另一模块引用

13.2 dir()

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回

python 复制代码 
print(dir(support))

# ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'log', 'log1']

14.输入和输出

14.1 读取键盘输入

input()

python 复制代码 
str = input("请输入：");
print ("你输入的内容是: ", str)

15.文件/目录操作

15.1 文件操作

**注意：**使用 open()方法一定要保证关闭文件对象，即调用close() 方法。

python 复制代码 
'''
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。
'''
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
模式 r r+ w w+ a a+
读 + + + +
写 + + + + +
创建 + + + +
覆盖 + +
指针在开始 + + + +
指针在结尾 + +

rb、rb+、wb、wb+、ab、ab+ 都是以二进制格式读写文件

文件对象的方法：

序号 方法及描述
1 file.close()关闭文件。关闭后文件不能再进行读写操作。
2 file.flush()刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3 file.fileno()返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4 file.isatty()如果文件连接到一个终端设备返回 True，否则返回 False。
5 file.next()**Python 3 中的 File 对象不支持 next() 方法。**返回文件下一行。
6 [file.read(size])从文件读取指定的字节数，如果未给定或为负则读取所有。
7 [file.readline(size])读取整行，包括 "\n" 字符。
8 [file.readlines(sizeint])读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9 [file.seek(offset, whence])移动文件读取指针到指定位置
10 file.tell()返回文件当前位置。
11 [file.truncate(size])从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。
12 file.write(str)将字符串写入文件，返回的是写入的字符长度。
13 file.writelines(sequence)向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

15.2 目录操作

os 模块：

序号 方法及描述
1 os.access(path, mode) 检验权限模式
2 os.chdir(path) 改变当前工作目录
3 os.chflags(path, flags) 设置路径的标记为数字标记。
4 os.chmod(path, mode) 更改权限
5 os.chown(path, uid, gid) 更改文件所有者
6 os.chroot(path) 改变当前进程的根目录
7 os.close(fd) 关闭文件描述符 fd
8 os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
9 os.dup(fd) 复制文件描述符 fd
10 os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2
11 os.fchdir(fd) 通过文件描述符改变当前工作目录
12 os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
13 os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
14 os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
15 [os.fdopen(fd, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
16 os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
17 os.fstat(fd) 返回文件描述符fd的状态，像stat()。
18 os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相等于 statvfs()。
19 os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘。
20 os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
21 os.getcwd() 返回当前工作目录
22 os.getcwdb() 返回一个当前工作目录的Unicode对象
23 os.isatty(fd) 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
24 os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接
25 os.lchmod(path, mode) 修改连接文件权限
26 os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。
27 os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src
28 os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。
29 os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效
30 os.lstat(path) 像stat(),但是没有软链接
31 os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
32 os.makedev(major, minor) 以major和minor设备号组成一个原始设备号
33 [os.makedirs(path, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
34 os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
35 [os.mkdir(path, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
36 [os.mkfifo(path, mode]) 创建命名管道，mode 为数字，默认为 0666 (八进制)
37 [os.mknod(filename, mode=0600, device]) 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
38 [os.open(file, flags, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的
39 os.openpty() 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
40 os.pathconf(path, name) 返回相关文件的系统配置信息。
41 os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
42 [os.popen(command, mode[, bufsize]]) 从一个 command 打开一个管道
43 os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
44 os.readlink(path) 返回软链接所指向的文件
45 os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
46 os.removedirs(path) 递归删除目录。
47 os.rename(src, dst) 重命名文件或目录，从 src 到 dst
48 os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。
49 os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
50 os.stat(path) 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
51 [os.stat_float_times(newvalue]) 决定stat_result是否以float对象显示时间戳
52 os.statvfs(path) 获取指定路径的文件系统统计信息
53 os.symlink(src, dst) 创建一个软链接
54 os.tcgetpgrp(fd) 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
55 os.tcsetpgrp(fd, pg) 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
56 os.tempnam([dir[, prefix]]) **Python3 中已删除。**返回唯一的路径名用于创建临时文件。
57 os.tmpfile() **Python3 中已删除。**返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。
58 os.tmpnam() **Python3 中已删除。**为创建一个临时文件返回一个唯一的路径
59 os.ttyname(fd) 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
60 os.unlink(path) 删除文件路径
61 os.utime(path, times) 返回指定的path文件的访问和修改的时间。
62 [os.walk(top, topdown=True[, οnerrοr=None[, followlinks=False]]]) 输出在文件夹中的文件名通过在树中游走，向上或者向下。
63 os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
64 os.path 模块 获取文件的属性信息。
65 os.pardir() 获取当前目录的父目录，以字符串形式显示目录名。
66 os.replace() 重命名文件或目录。

16 序列化与反序列化

Python3 中可以使用 json 模块来对 JSON 数据进行编解码，它主要提供了四个方法： dump、dumps、load、loads。

格式转换表：

16.1 序列化（dump，dumps）

  • dump

    python 复制代码 
    '''
obj -- 序列化对象
fp -- 文件描述符，将序列化的str保存到文件中。
skipkeys -- 默认为False。如果skipkeys是True则将跳过不是基本类型（str，int，float，bool，None）的dict键，不会引发TypeError
ensure_ascii -- 默认值为True，能将所有传入的非ASCII字符转义输出。如果ensure_ascii为False，则这些字符将按原样输出(ensure_ascii=False，让文件中的中文可以直接显示！)
check_circular -- 默认值为True。如果check_circular为False，则将跳过对容器类型的循环引用检查，循环引用将导致OverflowError
allow_nan -- 默认值为True。如果allow_nan为True，则将使用它们的JavaScript等效项（NaN，Infinity，-Infinity）。如果allow_nan为False，则严格遵守JSON规范，序列化超出范围的浮点值（nan，inf，-inf）会引发ValueError
indent -- 设置缩进格式，默认值为None，选择的是最紧凑的表示。如果indent是非负整数或字符串，那么JSON数组元素和对象成员将使用该缩进级别进行输入；indent为0，负数或""仅插入换行符；indent使用正整数缩进多个空格；如果indent是一个字符串（例如"\t"），则该字符串用于缩进每个级别。
separators -- 去除分隔符后面的空格，默认值为None。如果指定，则分隔符应为（item_separator，key_separator）元组。如果缩进为None，则默认为（'，'，'：'）；要获得最紧凑的JSON表示，可以指定（'，'，':'）以消除空格。
default -- 默认值为None。如果指定，则default应该是为无法以其他方式序列化的对象调用的函数。它应返回对象的JSON可编码版本或引发TypeError。如果未指定，则引发TypeError。
sort_keys -- 默认值为False。如果sort_keys为True，则字典的输出将按键值排序。
'''
json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

  • dumps

    python 复制代码 
    # dumps函数不需要传文件描述符(fp)，其他的参数和dump函数的一样。
json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

  • 例子

    python 复制代码 
    # dumps可以格式化所有的基本数据类型为字符串
data1 = json.dumps([])         # 列表
print(data1, type(data1))
data2 = json.dumps(2)          # 数字
print(data2, type(data2))
data3 = json.dumps('3')        # 字符串
print(data3, type(data3))
dict = {"name": "Tom", "age": 18}   # 字典
data4 = json.dumps(dict)
print(data4, type(data4))

with open("test.json", "w", encoding='utf-8') as f:
    # indent 格式化保存字典，默认为None，小于0为零个空格。indent=4缩进4个空格
    f.write(json.dumps(dict, indent=4))
#   json.dump(dict, f, indent=4)  # 传入文件描述符，和dumps一样的结果

16.2 反序列化（load，loads）

  • load

    python 复制代码 
    '''
fp -- 文件描述符，将fp（.read（）支持包含JSON文档的文本文件或二进制文件）反序列化为Python对象
object_hook -- 默认值为None，object_hook是一个可选函数，此功能可用于实现自定义解码器。指定一个函数，该函数负责把反序列化后的基本类型对象转换成自定义类型的对象。
parse_float -- 默认值为None。如果指定了parse_float，用来对JSON float字符串进行解码，这可用于为JSON浮点数使用另一种数据类型或解析器
parse_int -- 默认值为None。如果指定了parse_int，用来对JSON int字符串进行解码，这可以用于为JSON整数使用另一种数据类型或解析器
parse_constant -- 默认值为None,如果指定了parse_constant,对-Infinity,Infinity,NaN字符串进行调用。如果遇到了无效的JSON符号，会引发异常。如果进行反序列化（解码）的数据不是一个有效的JSON文档，将会引发 JSONDecodeError异常。
'''
json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

  • loads

    python 复制代码 
    '''
s -- 将s（包含JSON文档的str，bytes或bytearray实例）反序列化为Python对象

'''
json.loads(s, *, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

  • 例子

    python 复制代码 
    import json

dict = '{"name": "Tom", "age": 18}'   # 将字符串还原为dict
data1 = json.loads(dict)
print(data1, type(data1))

with open("test.json", "r", encoding='utf-8') as f:
    data2 = json.loads(f.read())    # load的传入参数为字符串类型
    print(data2, type(data2))
    f.seek(0)                       # 将文件游标移动到文件开头位置
    data3 = json.load(f)
    print(data3, type(data3))

17.错误和异常

python 复制代码 
try:  
    ## normal block  
except A:  
    ## exc A block  
except:  
    ## exc other block  
else:  
    ## noError block 
finally:
    ## 无论异常是否发生都会执行

17.1 抛出异常 raise

python 复制代码 
raise [Exception [, args [, traceback]]]

17.2 断言 assert

assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常

python 复制代码 
>>> assert 1==1    # 条件为 true 正常执行
>>> assert 1==2    # 条件为 false 触发异常

import sys
assert ('linux' in sys.platform), "该代码只能在 Linux 下执行"
# 接下来要执行的代码

17.3 with 关键字

with语句用于异常处理，封装了try...except...finally 编码范式，提高了易用性

python 复制代码 
'''
不使用 with，也不使用 try...except...finally
如果在调用 write 的过程中，出现了异常，则 close 方法将无法被执行，因此资源就会一直被该程序占用而无法被释放。
'''
file = open('./test_runoob.txt', 'w')
file.write('hello world !')
file.close()

'''
使用 try...except...finally 
对可能发生异常的代码处进行 try 捕获，发生异常时执行 except 代码块，finally 代码块是无论什么情况都会执行，所以文件会被关闭，不会因为执行异常而占用资源。
'''
with open('./test_runoob.txt', 'w') as file:
    file.write('hello world !')
    
# 使用 with 关键字系统会自动调用 f.close() 方法， with 的作用等效于 try/finally 语句是一样的。
with open('./test_runoob.txt') as f:
    f.write('hello world !')

18.面向对象

18.1 类

python 复制代码 
# 简单类实例
class People:
    # 构造函数
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def fun(self):
        return (self.name, self.age)
    
# 实例化类
p = People('ming', 18)

# 访问类的属性和方法
print(p.name)
print(p.fun())

18.2 类属性和方法

  • 类的私有属性
    __private_attrs ：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
  • 类的方法
    类方法必须包含参数 self ，且为第一个参数，self 代表的是类的实例
  • 类的私有方法
    __private_method ：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。
python 复制代码 
#!/usr/bin/python3
 
class Site:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url   	   # private
 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()
 
x = Site('菜鸟教程', 'www.runoob.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

18.3 类的专有方法

  • init : 构造函数，在生成对象时调用
  • del : 析构函数，释放对象时使用
  • repr : 打印，转换
  • setitem : 按照索引赋值
  • getitem: 按照索引获取值
  • len: 获得长度
  • cmp: 比较运算
  • call: 函数调用
  • add: 加运算
  • sub: 减运算
  • mul: 乘运算
  • truediv: 除运算
  • mod: 求余运算
  • pow: 乘方

18.4 继承

python 复制代码 
# 子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。
class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>
    
# BaseClassName（实例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:
class DerivedClassName(modname.BaseClassName):
python 复制代码 
#!/usr/bin/python3
 
#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
s = student('ken',10,60,3)
s.speak()

# ken 说: 我 10 岁了，我在读 3 年级

18.5 多继承

python 复制代码 
'''
需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。
'''
class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>
python 复制代码 
#!/usr/bin/python3
 
#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中参数位置排前父类的方法

# 我叫 Tim，我是一个演说家，我演讲的主题是 Python

18.6 方法重写

python 复制代码 
#!/usr/bin/python3
 
class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

# 调用子类方法
# 调用父类方法

19.作用域

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问

python 复制代码 
if True:
    msg = "hello world"
print(msg)
# hello world

def test():
    msg_inner = 'I am inner'
print(msg_inner)
# 未定义"msg_inner"

  • 全局变量和局部变量

    定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域

    python 复制代码 
    #!/usr/bin/python3
 
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2 # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total
 
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)

# 函数内是局部变量 :  30
# 函数外是全局变量 :  0

  • global 和 nonlocal 关键字
    当内部作用域想修改外部作用域的变量时，就要用到 global 和 nonlocal 关键字了

    python 复制代码 
    #!/usr/bin/python3
 
num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)

    如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了

    python 复制代码 
    #!/usr/bin/python3
 
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

19.1 特殊情况

python 复制代码 
#!/usr/bin/python3
 
a = 10
def test():
    a = a + 1
    print(a)
test()
# UnboundLocalError: cannot access local variable 'a' where it is not associated with a value
# 错误信息为局部作用域引用错误，因为 test 函数中的 a 使用的是局部，未定义，无法修改

#!/usr/bin/python3
 
a = 10
def test():
    global a
    a = a + 1
    print(a)
test()
# 11
相关推荐
橘子在努力6 分钟前
【橘子大模型】关于PromptTemplate
python·ai·llama
SheepMeMe24 分钟前
蓝桥杯2024省赛PythonB组——日期问题
python·算法·蓝桥杯
莓事哒33 分钟前
selenium和pytessarct提取古诗文网的验证码（python爬虫）
爬虫·python·selenium·测试工具·pycharm
q567315231 小时前
使用puppeteer库编写的爬虫程序
爬虫·python·网络协议·http
mosquito_lover11 小时前
Python数据分析与可视化实战
python·数据挖掘·数据分析
eqwaak01 小时前
量子计算与AI音乐——解锁无限可能的音色宇宙
人工智能·爬虫·python·自动化·量子计算
SylviaW081 小时前
python-leetcode 63.搜索二维矩阵
python·leetcode·矩阵
Ｓoｎｇ2 小时前
JVM 学习计划表（2025 版）
jvm·学习
跳跳糖炒酸奶2 小时前
第四章、Isaacsim在GUI中构建机器人（1）： 添加简单对象
人工智能·python·ubuntu·机器人
小杨爱学习zb2 小时前
学习总结 网格划分+瞬态求解设置
笔记·学习·算法
热门推荐
01我决定放弃搞 Java 了02DeepSeek各版本说明与优缺点分析03如何在WPS和Word/Excel中直接使用DeepSeek功能04RAG 实践- Ollama+RagFlow 部署本地知识库05苍穹外卖面试总结06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07Android下HWC以及drm_hwcomposer普法(上)08本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程09如何本地部署AI智能体平台，带你手搓一个AI Agent10循环神经网络RNN（含LSTM，GRU）小综述