python基础

发表于 | 分类于

概论

解释器中运行python代码

  1. 单行运行python
    在cmd输入python，在解释程序内直接输入代码回车执行。
  2. 直接运行python文件
    Python d:\test.py

注释

1
2
3
4
5
6
7
1. 单行注释
# 注释内容

2. 多行注释
"""
注释内容
"""

变量

  1. 定义变量，不用声明
  2. python中变量无类型，而数据有类型。
  3. 示例代码
    1
    2
    money = 50    
    print("账户余额 : " , money , "元")

数据类型

python需要处理的数据分为两种，数值型数据和字符。
所有的数据在计算机内部都是以二进制来存储的。

  • 数值型数据直接转换成二进制形式
  • 字符型需要进行编码(将每个字符对应一个数值型数据)

  1. 数据类型
    image

  2. 特殊数据类型None（空的，无意义的)

    1. 函数不写返回值时，返回None
    2. 作为初始值定义变量
    3. None 在if判断中表示False

  3. 查看数据类型 print(type("hello"))

  4. 类型转换

    1
    2
    3
    4
    5
    int(a)   # 转换整数，只有都是数字的字符串才可以转换成数字

    float(a) # 转换浮点数

    str(a)   # 转换字符串，任何类型都可以转字符串

标识符

  1. 标识符大概就是变量，方法，类的名字。
  2. 命名规则
    1. 标识符中只允许出现英文，中文，数字，下划线_
    2. 数字不允许开头
  3. 大小写敏感
  4. 不可以使用关键字
  5. 命名规范
    1. 变量命名全小写，不同单词用下划线分割。

运算符

  1. 算术运算符
    image

  2. 赋值运算符 =

  3. 复合赋值运算符
    将变量本身进行运算，然后再将结果赋值给变量本身。
    image

  4. 比较运算符
    image

字符串输出

字符串的拼接

1
2
# 拼接字符串和变量(只能是字符串变量) 
print("拼接字符串1" + str1)

利用占位符输出

字符串的格式化(解决字符串无法和其它类型完成拼接)

1
2
3
4
5
6
7
8
# 将变量变成字符串，放入占位地方
print("字符串占位拼接 %s" % str1)

print("字符串占位拼接 %s %s" % (str1，str2))

print("不换行输出", end='')  # 输出后不会自动换行

print(输出项，。。。,sep="",end="\n")  # sep输出间隔符

%s 变量转换成字符串，占位
%d 变量转换成整数，占位
%f 变量转换成浮点，占位

字符串宽度和精度控制%m.nd

  1. m宽度控制，多余用空格补足，小数和小数点也算在宽度内，当宽度小于数字本身则宽度控制无效。
  2. n表示精度控制，有几位小数，余下的四舍五入。
    1
    2
    3
    num = 3.28
    print("%5")    #_3.28
    print("%3")    #宽度控制无效

快速格式化

不限数据类型，不做精度控制

1
2
3
4
5
num = 24
print(f"我今年{num}岁了")

print("{} + {} = {}".format(5,6,11))
print("{1} {0}".format("b","a"))

对表达式进行格式化

表达式就是一条具有明确执行结果的代码语句。

1
2
3
print(f"我今年{22+2}岁了")
print("我今年%d"%(22+2))
print(f"字符串的类型{type("字符串")}")

数据输入

读取键盘输入input函数，回车结束。
只能输入字符串

1
2
3
4
5
name = input()
name = input("输入提示")

eval()  # 解析并执行字符串
x,y = eval(input("请输入两个数字，用逗号隔开"))

语句

if语句

1
2
3
age = 30  
if age > 30 :      # 判断条件是布尔类型
    print("输出")   # if通过缩进四格判断归属

代码演示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 判断年龄
age = int(input("输入年龄"))
if age > 30 :      
    print("输出")

# if else 语句
age = int(input("输入年龄"))
if age > 30 :      
    print("输出")
else :
    print("输出2")

# if elif 语句
if age > 30 :
    print("语句1")
elif age > 15 :
    print("语句2")
else :
    print("语句3")

# 省略输入
if int(input("输入年龄"))> 30 :      
    print("输出")

# if嵌套
age = int(input("语句1"))
if age > 30 :      
    print("语句2")
    age = int(input("语句3"))
    if age > 30 :      
        print("语句4")

循环语句

  1. while 循环

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    # 普通循环
    age = int(input("语句1"))
    while age > 30      # 布尔型判断条件
        print("语句2")   # 缩进判断归属
        age += 1        # 明确终止条件

    # 嵌套循环 
    i = 1
    while i <= 100 :
        print("语句1")
        i += 1
        j = 1
        while j <= 10
            print("语句2")
            j += 1

  2. for循环

    1. 对内容进行逐个处理
    2. 无法定义循环条件，只能被动的取出数据
    3. 空格缩进判断归属
    4. 临时变量的作用域
      循环内的临时变量在循环外部也能使用，但是不符合规范，要先定义
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      # 基本语句
      name = "hello"  
      for x in name :  # for 临时变量x in 序列类型(字符串，列表，元组)
          print(x)

      # for 循环的作用域与范围
      i = 5
      for i in range(5) :
        print(i)
      print(i)   # 输出 0,1,2,3,4,4

      # 嵌套循环
      for i in range(5) :     # 空格缩进判断归属
          for j in range(5) :

range语句(生成一个数据序列)

1
2
3
4
5
6
range(5)  {0,1,2,3,4} 
range(5,10)  {5,6,7,8,9} 
range(5,10,2)  {5,7,9}

for x in range(10) : 
    print(x)
  1. 循环控制
    1. continue
      1. 跳过本次循环，直接进行下一次
      2. 只作用在所在的循环上
    2. break 直接结束循环，只作用在所在的循环上

函数

  1. 函数是可重复使用的用来实现特定功能的代码块。
  2. 函数先定义，后调用
  3. 参数和返回值可以省略
  4. return 后面的语句都不执行
  5. 函数不写返回值时，默认返回None(在if判断时等同于false)

函数的定义与调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 函数定义
def 函数名 (传入参数) :
    函数体
    return 返回值

# 调用函数  
函数名(参数)  

# 实例
def add (x,y) :
    result = x + y
    print(f"{x}+{y}={x+y}")
    return result
add(1,2)
z = add(1,2)

函数的嵌套调用

  1. 函数的嵌套调用是指在一个函数里面，调用另一个函数
  2. python允许函数的嵌套调用，在函数中执行到被调函数，会跳转到被调函数执行，执行完成后才会继续执行主函数。

变量作用域

  1. 局部变量
    1. 定义在函数体内部的变量
    2. 只在函数体内部生效
  2. 全局变量
    1. 在函数体外部定义的变量
    2. 在函数体内和函数体外都生效的变量
      1
      2
      3
      4
      5
      6
      7
      8
      9
      a = 200
      b = 200
      def add () :
          a = 500  # 在函数体内部定义的局部变量a和全局变量a没有关系
          global b # 声明b是全局变量
          b = 500
      print(a)     # a是200
      print(b)     # b是500

函数的多返回值

image

函数参数使用形式

  1. 位置参数
    image

  2. 关键字参数
    image

  3. 不定长参数(可变传参)
    不确定调用时会传多少个参数

    1. 位置传递
      image
    2. 关键字传递
      image

  4. 缺省参数
    image

函数作为参数传递

  1. 函数本身可以作为参数传入另外一个函数使用。
  2. 函数作为参数传入的是计算逻辑，而非数据。
    image

lambda匿名函数

  1. 基础概念
    image
  2. 示例
    image
  3. 备注
    1. 只能写一条语句，不用写return语句，默认return结果。

异常

什么是异常

程序运行中出现的错误，弹出的错误提示。也就是常说的bug。

异常的捕获方法

  1. 为什么
    任何程序在运行中，都可能出现bug。我们要做的不是要求程序完美运行，而是对可能出现的bug提前准备，提前处理。防止程序因为一个bug而停止运行。
  2. 怎么捕获
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    1. 捕获所有异常
    try:
        可能发生错误的代码
    except Exception as e:
        如果出现异常执行的代码

    2. 捕获指定异常
    try:
        可能发生错误的代码
    except NameError as e:  # 指定捕获变量未定义异常，e是报的异常信息当成变量处理
        如果出现异常执行的代码

    3. 捕获多个异常
    try:
        可能发生错误的代码
    except (NameError, ZeroDivisionError) :  
        如果出现异常执行的代码

    4. 异常else和finally
    try:
        可能发生错误的代码
    except Exception as e:
        如果出现异常执行的代码
    else:
        没有出现异常执行的代码
    finally:
        无论如何都会执行的代码

异常的传递

异常具有传递性，它可以随着函数的调用关系向上传递。所以不需要去最底层真正出现异常的那句话去捕获，在更高的层级也是可以捕获的。

模块

是什么

模块就是一个python的代码文件，以.py结尾。
模块就是里面提供各种各样类，函数，变量的python文件
可以把模块看成一个工具包。

模块导入

image

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1. 全部导入
 import time  # 导入内置的time模块
 time.sleep(10)

from time import *   # 导入所有功能，与import time 相比调用功能方式不一样
sleep(5)

2. 导入需要的部分功能
from time import sleep
sleep(5)



3. 加别名
import time as t
t.sleep(10)

from time import sleep as sl
sl(5)

自定义模块

  1. 如何自定义模块
    直接创建python文件，写功能。
    当使用 from 模块 import 方法 导入多个模块的同名方法时，后导入的方法会覆盖前导入的方法
  2. 内置变量的使用
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    1. 被导入的模块，内部的方法调用会在导入时自动执行。使用python文件的内置变量__name__(运行程序时会标记为__main__)

    if __name__ == "__main__" :
       test(1,2)     # 该调用在模块导入时不会被执行

    2. 当被使用 from time import * 语句导入模块所以功能时，会先检查__all__变量，如果存在则只将该变量列表中的方法导入，不存在则导入全部功能。

    __all__ = ["test1"]  # from time import * 语句只能导入test1模块

    def test1():
        print("导入模块1")
    def test2():
        print("导入模块2")

包

包是什么

装有python模块和一个__init__.py 的文件夹

自定义包

1
2
3
4
5
6
7
1. 包的导入
from pkg import model
import pkg.model


2. 写在__init__.py里的all内置变量，当使用from pkg import * 导入时生效。
__all__ = ["model1"]

安装第三方包

  1. 什么是第三方包
    image

  2. pip安装第三方包

    1
    2
    3
    4
    5
    6
    7
    1. 传统安装(通过国外网站下载)
    打开cmd   
    pip install 包名称  
    pip install numpy 

    2. 清华大学镜像下载
    pip install -i https://pypi.tuna.tsinghua.edu.cn/simple some-package

面向对象

认识对象

为了有效的组织数据，使数据的组织达到简洁统一。
image

类的定义和使用

image

构造方法

image

其它内置方法

  1. __str__字符串方法
    控制类对象转换成字符串的行为。
    在你print对象时，输出你自定义的内容
    image

  2. lt 符号比较
    在对象中无法直接比较成员变量，<和>需要开通
    image

  3. le 比较
    用于小于等于符和大于等于符的比较

  4. eq 用于相等判断
    不使用内置方法，比较的是内存地址
    两个对象比较时，按照内置方法里描述的进行比较。
    image

封装

  1. 私有属性和方法
    私有属性和方法只可以让对象内部方法使用
    image

image

继承

image

image

调用时，先找子类，然后按顺序找父类

image

类型注解

  1. 变量的类型注解
    主要用于为函数，类的返回值等没办法一眼看出来的做注解。
    image

  2. 函数和方法类型注解
    image

  3. Union类型
    image

多态

  1. 同一个函数，参数定义是父类。传入不同的子类，会有不同的结果。
    image
  2. 用来定义抽象类
    image
  3. 抽象类是一种顶层设计，最为一种设计标准
    image