1、 前置知识

导读

Python 是一种面向对象、直译式计算机程序设计语言，也是一种功能强大而完善的通用型语言，已经具有十多年的发展历史。它可以运行于Microsoft Windows, Apple Mac OS X, GNU/Linux, BSD和很多其他的操作系统上。维基百科-python (opens new window)

Python是一种易于学习，强大的编程语言。 它具有高效的高级数据结构和简单而有效的面向对象编程的方法。 Python的优雅语法和动态类型，以及其解释性质，使其在许多领域成为大多数平台上的的用于脚本和快速应用程序开发的理想语言。

Python的一些显著特性：

• 语法优雅，使你编写的程序更易阅读。
• 易于使用，使得你的编程工作很简单。这使得Python非常适合原型开发和其他个性化（ad-hoc）编程任务，而不会影响可维护性。
• 附带一个大的标准库，支持许多常见的编程任务，如连接到Web服务器，使用正则表达式搜索文本，读取和修改文件。
• Python的交互模式使得测试短代码片段变得很容易。还附带一个称为IDLE的开发环境。
• 可以轻松地通过添加新的以编译语言（如C或C++）实现的模块来扩展。
• 也可以嵌入到应用程序中提供可编程接口。
• 可在任何平台运行，包括Mac OS X ， Windows ， Linux和Unix。
• 在两个意义上是自由软件。 你可以免费下载或使用Python，或将其包括在你的应用程序中。 Python也可以被自由地修改和重新分发，因为虽然该语言是受版权保护的，但它是根据开源许可证提供的。

Python的一些编程语言特性：

• 提供了各种基本数据类型：数字（浮点数，复数和无限长整数），字符串（ASCII和Unicode），列表和字典。
• Python支持使用类和多重继承的面向对象编程。
• 代码可以分组成模块和包。
• 该语言支持抛出和捕获异常，从而实现更简洁的错误处理。
• 数据类型健壮且动态类型化。混合不兼容的类型（例如，尝试添加字符串和数字）会导致引发异常，因此错误会更快被捕获。
• Python包含高级编程功能，如生成器和列表推导式。
• Python的自动内存管理使您无需在代码中手动分配和释放内存。

安装

无非就是下载依赖，然后配置环境变量，然后 coding……，这个过程就不赘述了……

• 下载地址 (opens new window)

• 文档地址 (opens new window)

2、Hello world

安装好第一件事当然是 输出一句 Hello world ！(别问我为什么)

print('Hello wrold')

3、基本知识

常见关键字

False      class      finally    is         return
None       continue   for        lambda     try
True       def        from       nonlocal   while
and        del        global     not        with
as         elif       if         or         yield
assert     else       import     pass
break      except     in         raise

解释

1. def：定义函数
2. if、else、elif：条件语句
3. for、while：循环语句
4. in：判断元素是否在序列中
5. is: 是否全等于 ，等价于 ==
6. and、 or、 not：逻辑运算符 ,分别等价于 && 、|| 、!=
7. True、False、None：布尔值和空值
8. class、return、yield：定义类、返回值、生成器函数
9. import、 from、 as：导入模块、从模块中导入函数或变量、给模块赋予别名
10. try、except、finally：异常处理语句
11. assert：断言语句，用于测试代码的正确性
12. global：定义全局变量
13. lambda：定义匿名函数

注意: 标粗部分需要注意，是与 其他 语言不同或者新增的

基本类型

• 整型 ：表示整数，可以是正整数、负整数或零

• 浮点型 : 用于表示浮点数，包括小数和科学计数法表示的数值。

• 字符串 ：表示文本字符序列，可以使用单引号、双引号或三引号来创建

• 列表 ： 表示有序、可变的数据集合，其中每个元素可以是不同的数据类型。

• 元组 ： 表示有序、不可变的数据集合，其中每个元素可以是不同的数据类型。

• 字典 : 表示无序、键值对的数据集合，其中每个键都是唯一的，对应一个值。

• 空类型 表示函数的返回值为空，或变量的初始值为空

• 布尔类型 两个值:真或者假 False ,True 注意需要大写

拓展类型

• 模块
• 自定义类型

使用关键函数 type() 可以输出参数类型

示例

# 导入模块 os （os 模块为系统内置模块）
import os

# 自定义类型
class D:
  pass

# 基本
print(type(1)) # <class 'int'>
print(type(1.1)) # <class 'float'>
print(type('hello world')) # <class 'str'>
print(type({'key':'value'})) # <class 'dict'>
print(type({1,2,3,4})) # <class 'set'>
print(type((1,2,3,4,'hello','world'))) # <class 'tuple'>
print(type([1,2,3,4,4])) # <class 'list'>
print(type(False)) # <class 'bool'>
print(type(None)) # <class 'NoneType'>

# 拓展
print(type(os)) # <class 'module'>
print(type(D())) # <class '__main__.D'>

常见工具函数

1. range()：用于生成一个整数序列，常用于 for 循环中。语法为 range(start, stop[, step])，其中 start 是起始值（默认为 0）、stop 是终止值（不包含），step 是步长（默认为 1）。

2. len()：用于获取一个序列类型对象（如字符串、列表、元组等）的长度或元素个数。

3. dir()： 用于返回指定对象的属性和方法列表。如果没有指定对象，则返回当前作用域内的所有属性和方法列表。

4. type(): 用于返回给定对象的类型。

5. sorted()：用于对一个可迭代对象进行排序，并返回一个新的列表。语法为 sorted(iterable, key=None[, reverse=False])，其中 iterable 是要排序的可迭代对象，key 是排序函数（默认为 None，表示使用默认规则进行排序），reverse 是是否降序排序（默认为 False）。

6. zip()：用于将多个可迭代对象打包成一个元组序列，并返回一个迭代器。例如，zip(list1, list2) 可以将两个列表按顺序打包成一个元组序列。

7. enumerate()：用于将一个可迭代对象生成一个索引序列和对应的值的元素序列，常用于 for 循环中。例如，enumerate(seq) 可以将一个序列 seq 转换为一个索引-值对的元素序列。

8. open()：用于打开一个文件，并返回一个文件对象。语法为 open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True)，其中 file 是文件名或文件路径，mode 是打开模式（默认为 'r'，表示只读模式），encoding 是文件编码格式（默认为 None，表示使用系统默认编码）。

9. input()：用于从控制台读取用户的输入数据，并返回一个字符串类型的值。

10. print()：用于将一组值输出到控制台或文件。语法为 print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)，其中 objects 是要输出的一个或多个值，sep 是分隔符（默认为空格），end 是结尾字符（默认为换行符），file 是输出的文件对象（默认为 sys.stdout，即标准输出），flush 表示是否立即刷新缓存区（默认为 False）。

常见内置的库

1. os：提供了访问操作系统功能的接口，如文件和目录操作、进程管理等。
2. sys：提供了对 Python 解释器进行访问的接口，例如通过命令行参数传递参数、获取当前模块的信息等。
3. math：提供了数学运算相关的函数，如三角函数、指数、对数、常数 PI 等。
4. datetime：提供了时间和日期处理相关的函数和类，如日期计算、格式化输出等。
5. random：提供了生成随机数的函数，如生成随机整数、浮点数、随机打乱列表等。
6. time：提供了时间相关的函数，如计时器、睡眠、格式化时间戳等。
7. json：提供了 JSON 数据的编码和解码功能。
8. csv：提供了 CSV 格式数据的读写功能。
9. re：提供了正则表达式相关的函数和类，如字符串匹配、替换等。
10. collections：提供了一些特殊的容器类型，如有序字典、命名元组等。

4、入门

基本使用

关于 位运算，逻辑运算 就不介绍了。

判断

is、in 、or、 and

print('hello' == 'hello') # True
print('hello' is 'hello') # True
print('hello' in 'hello') # True
print('hello' in 'hello world') # True
print('hello' in 'world') # False
print(False or True) # True
print(False and True) # False
print('p' not in 'python') # False
print( 'p' != 'python') # True
print('p' in 'hello wrold') # False
print('p' == 'python' ) # False

迭代

# 使用range 函数 遍历一个函数
for i in range(2):
  print(i)

# 也可以是一个范围
for i in range(2,100):
  print(i)

# 遍历字符串
for i in 'hello world':
  print(i)
  
# 遍历集合
for i in {'a','b','c','d'}:
  print(i)

# 遍历列表
for i in [1,2,34,4,45]:
  print(i)

# 遍历元组
for i in (1,2,3,4,'abc'):
  print(i)

# 遍历 字典
for i in {'a':'python','age':'12'}:
  print(i)

# 使用 enumerate 函数包装可以输出索引
for index,value in enumerate([1,2,3,43]):
  print(index,value)

字符串

构造字符串

• 直接赋值一个字符串
  • 单引号 ''
  • 双引号 ""
  • 三引号 ''' ''' 一般用于长文本，或者符号混乱不知道用什么就用它吧！
• 使用构造函数
  • str() 直接使用这个构造函数可以创建一个字符串

str1 = 'hello world'
str2 = "hello world"
str3 = '''hello world'''
str4 = str(1)
str5 = str({})
str6 = str([])

print(str1,type(str1),len(str1)) # hello world <class 'str'> 11
print(str2,type(str2),len(str3)) # hello world <class 'str'> 11
print(str3,type(str3),len(str3)) # hello world <class 'str'> 11
print(str4,type(str4),len(str4)) # 1 <class 'str'> 1
print(str5,type(str5),len(str5)) # {} <class 'str'> 2
print(str6,type(str6),len(str6)) # [] <class 'str'> 2

字符串方法

使用 dir() 函数可以直接输出

print(dir(str('')))

输出结果

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

很多方法时见名知意 这里就不演示了，无非就是对字符串 增、删除、改、查

比较特殊的是 以为 __XX__ 这种形式

下面看看 str 源代码

class str(Sequence[str]):
     # ...
    def __len__(self) -> int: ...
    def __iter__(self) -> Iterator[int]: ...
    @overload
    def __getitem__(self, __key: SupportsIndex) -> int: ...
    @overload
    def __getitem__(self, __key: slice) -> bytes: ...
    def __add__(self, __value: ReadableBuffer) -> bytes: ...
    def __mul__(self, __value: SupportsIndex) -> bytes: ...
    def __rmul__(self, __value: SupportsIndex) -> bytes: ...
    def __mod__(self, __value: Any) -> bytes: ...
    # Incompatible with Sequence.__contains__
    def __contains__(self, __key: SupportsIndex | ReadableBuffer) -> bool: ...  # type: ignore[override]
    def __eq__(self, __value: object) -> bool: ...
    def __ne__(self, __value: object) -> bool: ...
    def __lt__(self, __value: bytes) -> bool: ...
    def __le__(self, __value: bytes) -> bool: ...
    def __gt__(self, __value: bytes) -> bool: ...
    def __ge__(self, __value: bytes) -> bool: ...
    def __getnewargs__(self) -> tuple[bytes]: ...
    if sys.version_info >= (3, 11):
        def __bytes__(self) -> bytes: ...

通过源码可以知道一下特点

• 类的定义

  • class XXX(bbbb):
        pass
    

  • xxx 是类名

  • bbb 是父级

  • 上面简单表示 类 xxx继承类 bbb

• 在类中定义函数 第一个参数是 self ,其实就是 其他语言中的this 表示当前对象，不用输出

• 可以是使用内联函数

• 可以使用注解

• 可以指定参数类型 比如 __value: bytes

• ... 是什么意思？

  • 通常情况下，... 是不会被认为是有效的代码，它只是起到一个占位符的作用。

• 以双下划线开头和结尾的函数名是一类特殊的函数，通常被称为魔术方法（magic methods）或双下划线方法（dunder methods）。

  这些魔术方法有着特别的含义，它们可以被 Python 解释器自动调用，用于实现对于对象的特定操作。例如，定义一个类时，可以通过覆盖这些魔术方法来实现该类对象支持的运算、类型转换以及内建函数操作等。

具体详情会在下面类章节

额，好像扯远了……

迭代

python 中常见可迭代类有 列表 、字典、元组、集合,集合分为 有序集合和无序集合

另外: 字符串虽然不属于集合类型，但是将其看作一个由字符构成的序列，也就是说，它具有序列类型的特性。可以使用索引和切片访问字符串中的单个字符或子串，并且还支持一些序列操作，例如拼接、重复、迭代、长度获取等。同时，对于字符串类型来说，Python 还提供了一些特有的方法，例如字符串格式化、大小写转换、分割、连接等

集合创建

• 手动创建
• 构造函数创建

集合类型包括 set 和 frozenset

1. 创建集合

可以使用 set() 函数来创建一个集合，也可以使用花括号 {} 来创建一个集合。例如：

set1 = set([1, 2, 3, 4, 5])
set2 = {3, 4, 5, 6, 7}

2. 集合运算

可以对集合进行交集、并集、差集等运算。例如：

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}

# 交集
print(set1 & set2) # {3, 4, 5}
print(set1.intersection(set2)) # {3, 4, 5}

# 并集
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7}
print(set1.union(set2)) # {1, 2, 3, 4, 5, 6, 7}

# 差集
print(set1 - set2) # {1, 2}
print(set1.difference(set2)) # {1, 2}

3. 添加和删除元素

可以使用 add() 方法向集合中添加元素，使用 remove() 或 discard() 方法删除元素。区别是如果要删除的元素不在集合中，remove() 方法会抛出 KeyError 异常，而 discard() 方法不会抛出异常。例如：

set1 = {1, 2, 3}
set1.add(4)
print(set1) # {1, 2, 3, 4}

set1.remove(2)
print(set1) # {1, 3, 4}

set1.discard(5)
print(set1) # {1, 3, 4}

4. 可变集合和不可变集合

set 是一种可变类型的集合，而 frozenset 是一种不可变类型的集合。可以对 set 进行添加、删除等操作，但是对于 frozenset 来说，一旦创建，就不能再进行修改。例如：

set1 = {1, 2, 3}
set1.add(4)
print(set1) # {1, 2, 3, 4}

fset = frozenset([1, 2, 3])
print(fset) # frozenset({1, 2, 3})

需要注意的是，由于 frozenset 是不可变类型，因此它不支持 add() 和 remove() 等方法。

列表、元组和字典都是常用的数据类型

1. 列表

列表是一种有序的序列类型，每个元素都可以通过索引进行访问和修改。列表使用方括号 [] 定义，元素之间用逗号分隔。例如：

lst = [1, 2, 3, 4, 5] # 定义一个列表

print(lst[0]) # 访问第一个元素
lst[0] = 10 # 修改第一个元素
print(lst) # [10, 2, 3, 4, 5]

2. 元组

元组也是一种有序的序列类型，但是与列表不同的是，元组是不可变的，也就是说，一旦创建后就不能再修改它的值。元组使用圆括号 () 定义，元素之间用逗号分隔。例如：

tup = (1, 2, 3, 4, 5) # 定义一个元组

print(tup[0]) # 访问第一个元素，输出 1
tup[0] = 10 # 尝试修改第一个元素，会抛出 TypeError 异常

3. 字典

字典是一种无序的映射类型，它由键值对（key-value pairs）组成，每个键值对之间用逗号分隔。字典使用花括号 {} 定义，键和值之间使用冒号 : 分隔。例如：

dict1 = {'apple': 1, 'banana': 2, 'orange': 3} # 定义一个字典

print(dict1['apple']) # 访问键为 'apple' 的值，输出 1
dict1['apple'] = 10 # 修改键为 'apple' 的值
print(dict1) # {'apple': 10, 'banana': 2, 'orange': 3}

需要注意的是，字典是无序的，因此不能通过索引进行访问和修改。而是需要通过键来访问和修改对应的值。同时，一个键只能对应一个值，如果对同一个键赋值多次，后面的值会覆盖前面的值。

切片

通过切片（slice）来获取序列类型（如字符串、列表和元组）的子序列。切片语法使用方括号 []，在方括号中指定切片的起始索引和终止索引，中间用冒号 : 分隔。例如：

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

# 获取前三个元素
sub_lst1 = lst[0:3] # 或者 lst[:3]
print(sub_lst1) # 输出 [1, 2, 3]

# 获取第三个元素以后的所有元素
sub_lst2 = lst[2:] # 输出 [3, 4, 5]

# 获取最后两个元素
sub_lst3 = lst[-2:] # 输出 [4, 5]

需要注意的是，切片的起始索引是包含在切片中的，而终止索引是不包含在切片中的。因此，像 lst[0:3] 这样的切片会包含索引为 0、1 和 2 的元素，但是不包含索引为 3 的元素。

另外，如果切片的起始索引省略，表示从序列的开头开始切片；如果终止索引省略，表示切片到序列的结尾。例如，lst[:3] 表示从开头切片到索引为 2 的位置，lst[2:] 表示从索引为 2 的位置开始切片到结尾。

可以在冒号 : 后面指定一个步长（step），用于跳过一些元素。例如，lst[::2] 表示每隔一个元素取一个元素，输出 [1, 3, 5]。需要注意的是，当步长为负数时，起始索引和终止索引的顺序会被反转，例如，lst[::-1] 表示将列表反转，输出 [5, 4, 3, 2, 1]。

类

类是一种用于创建对象的抽象数据类型。定义一个类可以理解为定义一种新的数据类型，该类型可以拥有自己的属性和方法，并且可以通过实例化该类来创建对象。

作为一个类当然具有以下特点

• 封装
• 继承
• 多态

继承

演示一个继承

class MyStr(str):
  def __init__(self,args) -> None:
    print('mystr init ...')
    super().__init__()

  def __add__(self,value) -> None:
    print('mystr __add__ ...')
    super().__add__(value)
  
  def __ge__(self, __value: str) -> bool:
    print('mystr __ge__ ...')
    return super().__ge__(__value)
  def __le__(self, __value: str) -> bool:
    print('mystr __le__ ...')
    return super().__le__(__value)


b = MyStr('python')
c = MyStr('d')
print(b)
print(b+c)
print(b>=c)
print(b<=c)

输出结果

mystr init ...
mystr init ...
python
mystr __add__ ...
None
mystr __ge__ ...
True
mystr __le__ ...
False

以上自定义类 MyStr 继承了 str 重写了内置函数，可以调用一些运算符其实是默认调用了系统方法，

比如 b+c ===> b.__add__(c)， b>=c ===> b.__ge__(c)，在其他语言是字符串是无法直接通过逻辑运算符进行比较的,我所知道语言 C++ 是可以重载运算符的，但是也无法直接比较

可以自己重写方法，比如

b>=c 换成不是比较字符串长度，而是比较首字符

重写方法

class MyStr(str):
  def __ge__(self, __value: str) -> bool:
    print('mystr __ge__ ')
    return self[0]>=__value[0]
  def __le__(self, __value: str) -> bool:
    print('mystr __le__ ')
    return self[0]<=__value[0]


a = MyStr('ad')
b = MyStr('bcccc')
print(a>=b) # False
print(a<=b) # True

输出结果

mystr __ge__ 
False
mystr __le__
True

以上可以通过重写目的定制自己需求

重载 方法重载 python 不像其他语言对参数类型很严格，但是对参数个数是严格的

下面这个例子在其他语言中肯能是重载，但是python中同参数个数会被覆盖

class MyStr(str):
  def app1(self,args:int)->int:
    print('app1 int',)
    return args*10
  def app1(self,args:str)->str:
    print('app1 str',)
    return str(args)+"!hello world"



# 重载
a.app1(1) # 从输出结果看这个调用还是 第二个 app1 方法，说明这个不是重载，而是覆盖！
a.app1("python")


# 输出
app1 str
app1 str

从输出结果看，a.app1(1)并没有调用 int 参数的方法，可见同名函数，如果参数一致，后面会覆盖前面，其他语言不会覆盖

错误异常

通常来说，错误指的是程序遇到无法继续执行的严重问题，而异常则是一种可以被捕捉和处理的情况

以下是 Python 中常见的错误和异常：

1. 语法错误（SyntaxError）：程序在编译阶段就无法通过语法检查，通常是拼写错误、缺少括号或引号、代码格式不规范等原因导致。

2. 名称错误（NameError）：尝试访问一个未定义的变量或函数。

3. 类型错误（TypeError）：操作对象的类型错误，例如将整数和字符串相加。

4. 索引错误（IndexError）：试图访问一个不存在的序列索引。

5. 键错误（KeyError）：试图访问一个字典中不存在的键。

6. 文件不存在错误（FileNotFoundError）：试图打开一个不存在的文件。

7. 除零错误（ZeroDivisionError）：试图对一个数进行除零运算。

除了以上的错误之外，Python 还有很多内置的异常类型，例如 AssertionError、AttributeError、ImportError、IndentationError、NotImplementedError 等等。

当程序遇到异常时，可以使用 try...except 语句进行处理。例如：

try:
    num = int(input("请输入一个整数："))
    result = 100 / num
except ValueError:
    print("输入的不是整数")
except ZeroDivisionError:
    print("除数不能为零")
except:
    print("其他未知错误")
else:
    print(f"结果是：{result}")
finally:
    print("程序执行完毕")

手动抛出异常，其他语言手动抛出异常为 throw,python 使用的是 raise

b = 2

if b is 2:
  raise BaseException('b is not allow value is 2')

文件操作

好像没什么好说的，对文件的 读取，写入，追加，覆盖，

5、深入

• Python 标准库 (opens new window)

• 常见问题 (opens new window)

• 从github中学习python (opens new window)

最后

更多示例请阅读源代码，官方下载的python库自带很多示例

例如 文件夹xxxx\python\Tools 文件夹下就有很多示例，都是学习好文档

也可以从 github上面找更多学习 python 资料