# 基础环境
## Python环境安装(Windows)
```
1. 直接官网下载: 需要手动安装需要的包
    地址：https://www.python.org/
    安装的时候注意勾选添加环境变量
2. 安装anaconda: 已打包好常用的包
    地址：https://www.anaconda.com/
    安装的时候注意勾选添加环境变量
3. 百度AI Studio: 可以在线用
    地址： https://aistudio.baidu.com/
```
---
## Python环境安装(Linux)
```
    Linux往往会自带Python环境，但要注意版本
    如果没有安装，可以通过软件源安装
    在终端里面，执行“python”会默认调用Python2.x，执行“python3”会调用安装的python3.x
```
---
## 手动安装需要的包
```
    例如：
    python -m pip install -U pip
    python -m pip install -U numpy
    python -m pip install -U matplotlib
    更新包：
    pip install --upgrade package_ name
    Linux环境，如果没有pip，可以手动安装：
    sudo apt install python3-pip
```
---
## Python编辑器
```
1. 交互式命令行
    启动终端，执行命令：python
2. 自带的IDLE
    python自带的编辑器
3. IDE
    Jupyter Notebok
        安装python后，可通过pip命令安装：pip install jupyter
        启动命令：jupyter notebook
    pycharm
    vscode+python插件：可以直接在vscode里面使用jupyter，新建文件扩展名ipynb即可，但功能略有限制
        在程序中，如果导入上级目录出错，需要创建调试配置文件，添加一行："cwd": "${fileDirname}"
    eclipse+python插件
```
---
## Python程序运行方式
```
    Python是解释执行的程序，不需要编译，一遍解释一边执行，但也会生成字节码文件
    Python的运行类似于java，但有很大不同，最大的不同就是不需要编译
    通常的Python指的是CPython，即底层解释器是用C实现的，也有Java或其他语言的解释器
    Python基本文件是扩展名为 .py 的文本文件，通常称为Python脚本文件
    Python可以进行面向对象的程序设计、函数式编程等等编程范式
    Python可以很容易的粘合其他语言编写的组件
```
---
## 交互式环境
```
    终端里面执行命令 python ，Linux可能需要执行 python3 来启动3.x环境
    或者启动 IDLE SHELL
    交互式环境可以直接敲入python语句
    交互式环境有一个特殊变量：_  该变量用来保存上一次表达式计算的结果
    输入 exit() 退出交互式环境
```
---
## 运行.py文件
```
    命令：python xxx.py
    Linux下，可以将.py文件设置为可执行文件，直接运行，但要注意：.py文件的第一行需要添加相关注释
        #! /usr/bin/env python3
    将上面的注释添加到.py文件的第一行，在Linux 环境下表示以 python3 执行这个文件
```
---
## .py文件的编码问题
```
    默认情况下，.py文件以utf-8进行编码
```
---
## 版本问题
```
    通常情况下向下兼容，但3.x 和 2.x 不兼容，2.7 为2.x最终版
```
---

# 基本语法
## 缩进，代码块，行，注释
```
    python 使用缩进来组织代码块，不需要用大括号
    同一个代码块中的语句要保持缩进量相同，比如4个空格
    缩进可以使用tab或者空格，但是要统一，tab和空格不能混用，推荐使用4个空格
    通常，冒号意味着着后面要有一个缩进的代码块
    paython 每行结束不需要使用分号
    以 # 开头的行表示注释，注释也可以在每行语句的最后，必须以 # 开始
```
---
## 对象，变量
```
    python 中一切都是对象，Object 是所有对象的总类
    变量名即对象名，变量没有类型限制
    变量的内置函数、属性，使用 . 语法来调用
    使用 = 为变量赋值
    变量在第一次赋值时被创建
    变量可以赋值为 None ，类似java的NULL
```
---
## 常见数据类型
```
    str 字符串："abc" 'abc'
    int 有符号整型：-12
    float 浮点数：12.3344
    list 列表：[1,3,3]
    tuple 元组：(1,2)
    set 集合（集合中的值不可重复）：{1，2，3}
    dict 字典：{'a':1,'b':2,'c':3}
    布尔值:True False
```
---
## 模块，导入
```
    模块是以. py 为后缀名并包含 Python 代码的文件
    使用 import ... as ... 来导入模块并赋予一个别名，as 不是必须
    使用导入的模块中的函数、变量，使用：模块名（或别名）.对象名
    使用 from ... import as ... 来导入模块中特定的对象
```
---
## 运算符
```
    特殊的运算符：幂运算 ** (2**3 表示2的3次幂) ；整除（不保留小数） // (使用一个 / 的除法会保留小数部分)
    python 没有自增自减运算符（++和--）
    重复：'abc' * 2    #返回'abcabc'
    拼接：'abc' + 'def'    #返回'abcdef'
    相等：== （不等：!=）
```
---
## 可对象，变对象，不可变对象
```
    Python 中的大部分对象，例如列表、字典、NumPy数组都是可变对象，大多数用户定义的类型（ 类）也是可变的
    可变对象中包含的对象和值是可以被修改的：
    元组、字符串是不可变对象
```
---

# 字符串
## 字符串基本
字符串|s|t|r|i|n|g
---|:--:|:--:|:--:|:--:|:--:|:--:
索引值|0|1|2|3|4|5
负数索引|-6|-5|-4|-3|-2|-1
```
    字符串字面值用单引号 ' 或 双引号 " 包围
    多行文本可以用三个单引号或者三个双引号包围
    转义字符以 \ 起：a = "12\\12"
    也可以在字符串前面加 r 而不使用转义：a = r'12\\12'
    可以直接使用 + 对两个字符串拼接：s= str1 + str2
    print()函数用来向终端输出一串字符，默认将传入的对象转换为字符串：print([1,2,3])
    但是把用 + 拼接的对象传给print()函数时，需要显式将每个对象转换为字符串：print('a='+str(123))
    可以通过索引值取出字符串中的字符，起始为0，可以为负数，-1表示最后一个字符
```
---
## 字符串切片
```
    基本语法：字符串对象[起始索引:终止索引:步长]
        a[1:5:1]    #从索引号1开始，直到索引号5之前的字符，步长为1
    起始索引、终止索引、步长可以为空，默认为1，a[:] 相当于整个字符串a
    起始索引、终止索引、步长可以取负数
        a='123456'
        print(a[::-1])    #输出为：654321
        print(a[4::-1])    #输出为：54321
        print(a[2:5])    #输出为：345
```
---
## 字符串常用函数
```
    count() 计算给定字符在字符串中的个数：'12345'.count('2')
    find() 给定字符在字符中第一次出现的位置，找不到返回-1：'hello world'.find('o')    #返回4
    index() 给定字符在字符中第一次出现的位置，找不到报错
    split() 按给定字符对字符进行拆分，返回一个列表：'hello world'.split(' ')    #返回['hello', 'world']
    replace() 替换指定字符（或字符串）：'hello world'.replace(' ',',')    #返回'hello,world'
    strip() 去除字符串前后的空格、换行：str.strip()
    uper() 全体字符大写
    lower() 全体字符小写
    capitalize() 首字母大写，其他小写：'hello World'.capitalize()    #返回'Hello world'
```
---

# 格式化输出
## % 语法
```
    基本格式：
        print('this is %s' % 'an apple')    #输出：this is an apple
```

格式|描述|备注
---|:--:|---
%%|百分号标记|
%c|字符及其ASCII码|
%s|字符串
%d|有符号整数(十进制)
%u|无符号整数(十进制)已过时
%o|整数(八进制)
%x|整数(十六进制)
%X|整数(十六进制大写字符)
%e|浮点数字(科学计数法)
%E|浮点数字(科学计数法，用E代替e)
%f|浮点数字(用小数点符号)
%g|浮点数字(根据值的大小采用%e 或%f)
%G|浮点数字(类似于%g)
%p|指针(用十六进制打印值的内存地址)
%n|存储输出字符的数量放进参数列表的下一个变量中
```
    print('there are %d %s' % (5,'apples'))    #输出：there are 5 apples
    print('%.2f' % (5/3))    #输出：1.67
```
---
## format 语法
```
    s='{} have {:d} {} and {:.2f} L water'
    print(s.format('we', 5, 'apples', 2.7))    #输出 we have 5 apples and 2.70 L water

    s='{who:} have {q:d} {fruit:}'
    print(s.format(who='we', q=5, fruit='apples'))    #输出 we have 5 apples
```
---
## f-string 语法
```
    3.6版本加入
    who,q = 'we',2.7
    s=f"{who} have {q:.2f} L water"
    print(s)    #输出 we have 2.70 L water
```
---

# list 列表操作
## 索引，切片
```
    和字符串一样，列表支持通过索引获取元素，以及切片操作
```
---
## 常用函数、操作
```
    append() 在结尾添加元素：list1.append('apple')
    extend() 合并两个列表：list1.extend(list2)
    count() 计算某个元素值在列表中出现的次数：list1.count('a')
    index() 查找某个值在列表中第一次出现的索引：list1.index('a')
    判断某个值是否在列表中：'a' in list1    #如果 a 在 list1 中，返回True，否则返回False
    列表推导式：[2**x for x in range(12) if x%2==0]    #返回 [1, 4, 16, 64, 256, 1024]

```
---

# 异常处理
## 异常
```
    程序发生错误时，会引发异常处理
    当没有相应的异常处理方法时，python会跳出执行程序，终止程序运行
   
```
---
## 基本语法
```
    try/except
    try/except/else
    try/except/finally
    try/except/else/finally
   
    可以有多个except，对应不同的异常类型
    else只在没有异常发生时执行
    finally无论是否发生异常都会执行
    异常会层层传递
    raise可以手动引发一个异常
    assert可以有条件的引发一个异常

    def f(x):
        assert x<0, 'x must be negative'
        return x**2
    f(1)    #这会引发一个异常

```
---

# 函数
## 基本语法
```
    以 def 定义，可以有或没有参数
    通过return或yield返回参数
    return并非必须，执行到函数结尾自动退出
    没有定义return则会默认返回None
    可以利用打包拆包功能返回多个值
```
---
## 参数问题
```
    位置参数
    def f(x,y):
        pass
    f(1,2)    #在函数f内部，x=1，y=2

    默认值参数
    def f(x,y=2):
        pass
    f(1)    #在函数内部，x=1，y被赋值为默认值2

    可变参数
    def f(*values):
        for x in values:
            pass
    f(1,2,3)    #可传入0个或多个参数，在函数内部自动组成一个元组

    关键字参数
    def f(x,y,**n):
        print(n)
    f(1,2,m=3,n=4)    #允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict:{'m': 3, 'n': 4}

    命名关键字参数
    def f(x,y,*,m,n):
        pass
    f(1,2,m=3,n=4)    #调用时必须显式赋值
```
---
## lambda匿名函数
```
    只能写一行，返回的是一个函数

    f=lambda x,y:x+y
    f(1,2)    #结果3
```
---
## 生成器函数
```
def gen_num(value):
    i = 0
    while i <= value:
        yield i    #通过yield 返回值，然后暂停执行，直到下次调用
        i += 1
g=gen_num(12)

print([x for x in g])
```
---

# 类和对象
## 类定义
```
class Vehicle(object):    #object是所有类的父类，在此处可以不必写出
    memo = 'I can move'    #类属性
    def __init__(self,name):    #构造函数（初始化函数），初始化新创建的对象
        self.name = name    #绑定属性到对象
    def get_myname(self):    #定义对象的方法(函数)
        return self.name
    @classmethod    #装饰器
    def get_memo(cls):    #类方法要传入cls
        return cls.memo
car = Vehicle('my car')    #实例化对象
print(car.name)    #访问属性
print(car.get_myname())    #调用方法
print(Vehicle.memo)    #访问类属性
print(car.memo)    #此时访问的是类属性
Vehicle.memo="I have wheels"    #修改类属性
print(Vehicle.memo)    #访问类属性
print(car.memo)    #此时访问的是类属性
car.memo="I can run"    #给实例对象增加了一个不在类内定义的属性
print(car.memo)    #此时访问的是对象附件的属性
print(Vehicle.memo)    #访问类属性,类属性不受实例同名属性的影响
print(Vehicle.get_memo())    #调用类方法

```
---
## 伪私有化
```
class A:
    def __init__(self) -> None:
        self.__a=3    #不能直接通过.语法访问该属性
a=A()
aa=A()
aa._A__a=4    #但仍有办法去访问
print(a._A__a)
```
---
## 继承
```
```
---