安装

1. 安装python解释器，默认在安装过程中加入到环境变量中。
   • 安装包
   • 官方文档
   • 安装完成后，在IDLE中可以直接编写运行python代码；或者在终端（tty）输入python，进入解释器的交互模式（interactive mode）。
2. 解释器的运行环境
   • 源文件的字符编码：Python 源码文件以 UTF-8 编码方式处理，标准库中只用常规的 ASCII 字符作为变量或函数名。如果不使用默认编码，要声明文件所使用的编码，文件的 第一 行要写成特殊的注释，如下：
     # -*- coding: encoding -*-encoding 可以是 Python 支持的任意一种 codecs

   • 在交互模式下，上一次打印出来的表达式被赋值给变量 _。

     
     
     image.png

基本语法

1. 数字 类似JS

2. 字符串：在 Python 中处理文本数据是使用 str 对象，也称为 字符串。 字符串是由 Unicode 码位构成的不可变文本序列类型 。

   • 字符串字面值有多种不同的写法：可以使用 单引号或者双引号声明字符串字面量，以 \ 来 转义特殊符 号，或者使用三重引号使得字符串字面量可以换行。
   • 相邻字符串会自动拼接，把很长的字符串拆开分别输入的时候尤其有用。
   • 如果不希望前置了 \ 的字符转义成特殊字符，可以使用原始字符串 方式，在引号前添加 r 即可:

   >>> print('C:\some\name')  # here \n means newline!
   C:\some
   ame
   >>> print(r'C:\some\name')  # note the r before the quote
   C:\some\nam
   

   • +可以拼接字符串，*重复字符串
   • 字符串可以被索引，索引是负数就从右边开始计数，从 -1 开始计数。

   name= "hgz"
   print(name[0]) #h  
   print(name[-2]) #g
   

   • 字符串还支持切片，得到一个字符串片段，含头不含尾，可以省略参数。

   name= "gzhuang"
   print(name[0:3]) #gzh
   print(name[:2] + [2:]) #gzhuang
   

   • 字符串是不可修改的，比如你不能用name[0] = "a" 的方式去修改一个字符串。
   • 内建函数 len(name)返回一个字符串的长度。
   • 字符串方法

3. 列表：Python 中可以通过组合一些值得到多种 复合 数据类型。其中最常用的 列表 ，可以通过方括号括起、逗号分隔的一组值得到。一个 列表 可以包含不同类型的元素，但通常使用时各个元素类型相同。

   • 列表也支持索引和切片，可以给切片赋值（这样做会改变原列表）。

   list1 = [1, 2, 3]
   list1[1] #2
   list1[0:] #[1, 2, 3]
   list1[1:2] = []
   print(list1) #[1, 3]
   

   • 列表也支持拼接。列表是一个mutable类型的数据，内容是可改变的。
   • 内置函数 len() 也可以作用到列表上，返回列表的长度。

4. 流程控制语句

   • if...elif...else

   num = 10
   if num > 10:
       print("大于10")
   elif num > 5 & num <= 10:
       print("大于5小于等于10")
   else:
       print("小于5")
   

   • for Python 中的 for 语句并不总是对算术递增的数值进行迭代（如同 Pascal），或是给予用户定义迭代步骤和暂停条件的能力（如同 C），而是对任意序列进行迭代（例如列表或字符串），条目的迭代顺序与它们在序列中出现的顺序一致。

     >>> # Measure some strings:
     ... words = ['cat', 'window', 'defenestrate']
     >>> for w in words:
     ...     print(w, len(w))
     ...
     cat 3
     window 6
     defenestrate 12
   

   1. range()函数：如果你确实需要遍历一个数字序列，内置函数range()会派上用场。range()返回一个iterable，而不是一个list，可以通过list(iterable)的方式转成一个列表

   >>> a = ['Mary', 'had', 'a', 'little', 'lamb']
   >>> for i in range(len(a)):
   ...     print(i, a[i])
   ...
   0 Mary
   1 had
   2 a
   3 little
   4 lamb
   

   2. break 和continue：与C语言中用法相同
   3. 循环语句可能带有 else 子句；它会在循环耗尽了可迭代对象 (使用 for) 或循环条件变为假值 (使用 while) 时被执行，但不会在循环被 break)语句终止时被执行。
   • pass：当语法上需要一个语句，但程序需要什么动作也不做时，可以使用它。

5. 函数

   • 定义：

   def fib(n):
       a, b = 0, 1
       while a < n:
           print(a, end="---")
           a, b = b, a + b
       print()
   
   
   fib(1000)
   

   • 默认参数, 默认值只会执行一次，如果这个值是一个对象，多次执行函数会工作一个默认值。如果不想共享参数，可以在函数里面写判断条件，如果没有赋值，给一个初始值。
   • 在函数调用中，关键字参数必须跟随在位置参数的后面。
   • 特殊参数：如果函数定义中未使用 / 和 *，则参数可以按位置或按关键字传递给函数。 仅限位置形参（positional-only arguments）要放在 / (正斜杠) 之前，这个 / 被用来从逻辑上分隔仅限位置形参和其它形参。要将形参标记为 仅限关键字，即指明该形参必须以关键字参数的形式传入，应在参数列表的第一个 keyword-only 形参之前放置一个 *。
     def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
   • 任意参数列表，这些参数包含在一个元组里面。（在这个参数后面的形参只能是关键字参数）
     def f( *args):
   • 可以使用 *操作符 来编写函数调用以便从列表或元组中解包参数，而字典可使用 ** 操作符 来提供关键字参数。（可以理解为js中的...）
   • Lambda 表达式：创建一个匿名函数，在语法上限于单个表达式，从语义上来说，它们只是正常函数定义的语法糖。

   >>> def make_incrementor(n):
   ...     return lambda x: x + n
   ...
   >>> f = make_incrementor(42)
   >>> f(0)
   42
   >>> f(1)
   43
   

数据结构

1. 列表
   • 列表list：列表的相关方法使得列表可以当成栈和队列来使用。
   • 列表推导式提供了一个更简单的创建列表的方法。常见的用法是把某种操作应用于序列或可迭代对象的每个元素上，然后使用其结果来创建列表，或者通过满足某些特定条件元素来创建子序列。

   squares = list(map(lambda x: x**2, range(10))) 
   # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
   coordinate = list((x, y) for x in [1, 2] for y in [1, 2] if x == y)
   # [(1, 1), (2, 2), (3, 3)]
   

   • 嵌套的列表推导式

   [[row[i] for row in matrix] for i in range(4)] 
   # [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
   # 等价于
   outer = []
   for i in range(4):
       inner = []
       for row in matrix:
           inner.append(row[i])
       outer.append(inner)
   print(outer) # [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
   # 也可以
   list(zip(*matrix)) # [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
   

   • del 语句 :有一种方式可以从列表按照给定的索引而不是值来移除一个元素: 那就是del语句，del 语句也可以用来从列表中移除切片或者清空整个列表，也可以被用来删除整个变量。
2. 元组
   • 声明方式：输入时圆括号可有可无，不过经常会是必须的（如果这个元组是一个更大的表达式的一部分）。

   t1 = 1, 2, 3
   t2 = (1, 2, 3)
   print(t1 == t2) #True
   

   • 元组可以嵌套

   t3 = (t1, 4)
   t4 = (*t1, 4)
   print(t3, t4) # ((1, 2, 3), 4) (1, 2, 3, 4)
   

   • 元组是 immutable （不可变的）
   • 创建空元组和单例元组

   empty = ()
   singleton = 'hello',    # <-- note trailing comma
   len(empty) #0
   len(singleton) #1
   singleton # ('hello',)
   

   • 序列解包：解包操作的等号右侧可以是任何序列，序列解包要求等号左侧的变量数与右侧序列里所含的元素数相同。可变参数其实也只是元组打包和序列解包的组合。

   arg1 = [1, 2]
   x, y = arg1
   print(x, y) # 1 2
   arg2 = (3, 4)
   x1, y1 = arg2
   print(x1, y1) #3 4
   

3. 集合：集合是由不重复元素组成的无序的集。
   • 集合对象也支持像 联合，交集，差集，对称差分等数学运算。

   a = set('abcde')
   b = set('abc')
   print('a' in a)  # true
   print(a - b)  # {'e', 'd'}
   print(a & b)  # {'b', 'a', 'c'}
   

   • 推导式

   c = {x for x in 'abracadabra' if x not in 'abc'}
   print(c)  # {'d', 'r'}
   

4. 字典：字典是以 关键字 为索引的，关键字可以是任意不可变类型，通常是字符串或数字。
   • 对一个字典执行 list(d) 将返回包含该字典中所有键的列表，要检查字典中是否存在一个特定键，可使用in关键字。
   • dict()构造函数可以直接从键值对序列里创建字典。

   >>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
   {'sape': 4139, 'guido': 4127, 'jack': 4098}
   

   • 字典推导式可以从任意的键值表达式中创建字典

   >>> {x: x**2 for x in (2, 4, 6)}
   {2: 4, 4: 16, 6: 36}
   

模块

1. 引入

import fibo
from fibo import fib, fib2
from fibo import *
import fibo as fib

2. 模块搜索路径
   当一个名为 spam 的模块被导入的时候，解释器首先寻找具有该名称的内置模块。如果没有找到，然后解释器从 sys.path 变量给出的目录列表里寻找名为 spam.py 的文件。sys.path 初始有这些目录地址:

• 包含输入脚本的目录（或者未指定文件时的当前目录）。

• PYTHONPATH （一个包含目录名称的列表，它和shell变量 PATH 有一样的语法）。

• 取决于安装的默认设置

3. 包
   from sound.effects import *

输入输出

1. 格式化输出

name = "hgz"
age = 18
print(f"name = {name}, age = {age}")  # name = hgz, age = 18

2. 字符串format

>>> print('We are the {1} who say "{0}!"'.format('knights', 'Ni'))
We are the Ni who say "knights!"

>>> print('This {food} is {adjective}.'.format(
...       food='spam', adjective='absolutely horrible'))
This spam is absolutely horrible.

3. 文件读写

• open() 返回一个 file object，最常用的有两个参数： open(filename, mode)。在处理文件对象时，最好使用 with关键字。 优点是当子句体结束后文件会正确关闭，即使在某个时刻引发了异常。 而且使用 with 相比等效的 try finally 代码块要简短得多:
• fs.read(size):它会读取一些数据并将其作为字符串（在文本模式下）或字节串对象（在二进制模式下）返回。它会读取一些数据并将其作为字符串（在文本模式下）或字节串对象（在二进制模式下）返回。

4. 使用json保存格式化数据

>>> import json
>>> json.dumps([1, 'simple', 'list'])
'[1, "simple", "list"]'

• dumps()函数的另一个变体叫做 dump()，它只是将对象序列化为 text file 。因此，如果 f 是一个 text file 对象，我们可以这样做:

json.dump(x, f)
# 解码
x = json.load(f)

异常处理

try ..... except...

while True:
    try:
        x = int(input("please input a number:"))
        print("your input number is", x)
        break
    except ValueError:
        print("this is not a number,please input again!")

1. try语句的工作原理如下。

   • 首先，执行 try 子句 关键字之间的（多行）语句）。

   • 如果没有异常发生，则跳过 except 子句 并完成 [try] 语句的执行。

   • 如果在执行try 子句时发生了异常，则跳过该子句中剩下的部分。然后，如果异常的类型和 [except] 关键字后面的异常匹配，则执行 except 子句 ，然后继续执行 [try] 语句之后的代码。

   • 如果发生的异常和 except 子句中指定的异常不匹配，则将其传递到外部的 [try]语句中；如果没有找到处理程序，则它是一个 未处理异常，执行将停止并显示如上所示的消息。

2. 一个 except 子句可以将多个异常命名为带括号的元组，例如:

   except (RuntimeError, TypeError, NameError):
       pass
   

3. `try...except语句有一个可选的 else 子句，在使用时必须放在所有的 except 子句后面。对于在try 子句不引发异常时必须执行的代码来说很有用。例如:

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except OSError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

4. 抛出异常 raise关键字
5. 定义清理操作 finally关键字

面向对象

1. 类：python类是 C++ 和 Modula-3 中类机制的结合，类继承机制允许多个基类，派生类可以覆盖它基类的任何方法，一个方法可以调用基类中相同名称的的方法

   • 定义类 ：__init__()方法相当于构造函数，在类中所有实例方法第一个参数默认是self，指向创建的实例对象，实例方法可以通过实例对象或者类对象直接调用。类方法可以通过类对象或实例对象调用，第一个参数默认是当前类对象的引用。静态方法也可以通过这两种方式调用，默认不传入参数。

   class Student:
       def __init__(self, name):
           self.name = name
   
       def study(self):
           if self.name == "hgz":
               print("good student")
           else:
               print("not that good student")
   
       def print_self(self):
           print(self)
   
       @classmethod
       def say(cls):
           print(cls)
   
       @staticmethod
       def buy(money):
           print(money)
   
   
   student = Student("hgz")
   student.study()  # good student
   
   # 实例方法的调用
   student.print_self()  # <__main__.Student object at 0x000002B804BF8430>
   Student.print_self(student)  # <__main__.Student object at 0x000002B804BF8430>
   
   # 类方法的调用
   Student.say()  # <class '__main__.Student'>
   student.say()  # <class '__main__.Student'>
   
   # 静态方法的调用
   Student.buy("Student class $20")  # Student class $20
   student.buy("student instance $10")  # Student class $20
   

   • python支持多继承

   class DerivedClassName(Base1, Base2, Base3):
   <statement-1>
   .
   .
   .
   <statement-N>
   

2. Python 作用域和命名空间

   • namespace （命名空间）是一个从名字到对象的映射，例如存放内置函数的集合 、模块中的全局名称、函数调用中的局部名称等都是命名空间。
   • nonlocal语句会使得所列出的名称指向之前在最近的包含作用域中绑定的除全局变量以外的变量。
   • global它意味着所列出的标识符将被解读为全局变量。

3. 迭代器

   • for语句会调用容器对象中的 iter()。 该函数返回一个定义了 __next__()方法的迭代器对象，该方法将逐一访问容器中的元素。 当元素用尽时，__next__()将引发 StopIteration异常来通知终止 for 循环。 你可以使用 next() 内置函数来调用 __next__() 方法；

   str = "abcd"
   iterator = iter(str)
   print(next(iterator))  # a
   print(next(iterator))  # b
   print(next(iterator))  # c
   print(next(iterator))  # d
   print(next(iterator))  # StopIteration
   

4. 生成器

   • Generator 是一个用于创建迭代器的简单而强大的工具。 它们的写法类似标准的函数，但当它们要返回数据时会使用 yield 语句。 每次对生成器调用 next()时，它会从上次离开位置恢复执行（它会记住上次执行语句时的所有数据值）。