Python基础

寒点

一、数据类型

1. 变量

1.1 定义

• Python 与其他语言的区别：
  
  
  
  • Python：变量相当于标签
    
  • 其他语言：变量相当于容器
    
  
  
• 先赋值后使用
  

1. str = "hello"
2. print(str)

复制代码

1.2 变量的数据类型

• 静态类型语言：在使用变量之前定义其数据类型
  
• 动态类型语言：在给变量赋值时确定其数据类型，对变量的每一次赋值，都有可能改变变量的类型
  

【Python 就是动态类型语言】
1.3 查看变量数据类型

• 语法：type(变量)
  
• 可以直接输出，也可以用变量存储结果再输出
  
• type()查看的是变量存储的数据的类型，即变量无类型
  

2. 标识符

• 由字母、数字、下划线组成，不能以数字开头，且区分大小写（可用中文，但不推荐）
  
• 单独的下划线_是一个特殊变量，表示上一次运算的结果
  
• 见名知意
  
• 关键字大写后可作为标识符
  

1. >>> 55
2. 55
3. >>> _+100
4. 155

复制代码

3. 字面量

• 在代码中被写下来的固定的值
  
• Python 中常用的6种数据类型
  

类型描述说明数字（Number）支持：整数、浮点数、复数、布尔复数：4+3j（以 j 结尾表示复数）字符串（String）描述文本的一种数据类型由任意数量的字符组成列表（List）有序的可变序列可有序记录一堆数据（最常用）元组（Tuple）有序的不可变序列可有序记录一堆不可变的数据集合集合（Set）无序不重复集合可无序记录一堆不重复的的数据集合字典（Dictionary）无序 Key-Value 集合可无序记录一堆 Key-Value 型的数据集合

• 科学计数法
  
  
  
  • e（E）表示以10为底的指数，e 之前为数字部分，之后为指数部分，而两部分必须同时出现，指数必须为整数
    
  
  

1. 45e-5        # 0.00045

复制代码

• 复数型数据
  

1. a+bJ 或 a+bj

复制代码

可通过x.real和x.imag来分别获取 x 的实部和虚部，结果都是浮点型

1. >>> x.real
2. 12.0
3. >>> x.imag
4. 34.0

复制代码

4. 转换类型

4.1 为什么

• 从文件中读取的数字，默认是字符串，需要转换成数字类型
  
• input()语句默认结果是字符串，有数字也需要转换
  
• 将数字转换成字符串用以写出到外部系统
  

4.2 常见的转换语句

语句（函数）说明int(x)转换为整数float(x)转换为浮点数str(x)将对象 x 转换为字符串注：浮点数转换为整数时会丢失精度
二、注释

• 单行注释
  

1. # 我是单行注释

复制代码

• 多行注释
  

1. """
2.         我是多行注释
3. """

复制代码

• 工作日志说明：进行没有完成的功能备注
  

1. # TODO 说明文字

复制代码

三、运算符

1. 算术运算符

• 基本运算：加、减、乘、除、取余
  
• 其他：
  
  
  
  • //：取整除，c **= a等价于c = c ** a
    
  • **：指数，c //= a等价于c = c // a
    
  
  

2. 链式比较

在 Python 中，可以使用链式比较对多个值进行比较，简化代码

1. x = 5
2. print(1 < x < 10)  # 输出 True，相当于 1 < x and x < 10
3. print(1 < x > 3)  # 输出 True，相当于 1 < x and x > 3
4. print(1 <= x < 5)  # 输出 False，相当于 1 <= x and x < 5

复制代码

嵌套语句：

1. length = 23
2. height = 23
3. width = 6
5. if length == height and height == width and width == length:
6.     print("This is a cube")
7. else:
8.     print("This is a cuboid")
10. # 简化代码
11. if length == height == width:
12.     print("This is a cube ")
13. else:
14.     print("This is a cuboid ")

复制代码

注意条件设置，避免造成死循环
2. 补充知识

2.1 print 输出不换行

默认 print 输出时自动换行，只要在print中加上end = ' '，即可输出不换行

1. name = input()

复制代码

2.2 制表符 \t

可以实现多行字符串对齐

案例：打印九九乘法表

1. name = input("你是谁？")
2. print("哦，你是：%s" % name)

复制代码

示例：

1. id(object)        # object：任何对象，字符串、数字、列表等等

复制代码

4.4 Union 类型

4.4.1 引入

• 这种情况好写
  

1. del x

复制代码

• 下面这种情况怎么写类型注解呢？
  

1. if 条件:
2.         ...
3. elif 条件2:
4.         ...
5. else:
6.         ...

复制代码

4.4.2 语法

• Union 联合类型注解，在变量注解、函数（方法）形参和返回值注解中均可使用
  

1. if guess == secret:
2.         print("猜中了！")
3. else:
4.         if guess > secret:
5.                 print("猜大了")
6.         else:
7.                 print("猜小了")

复制代码

5. 多态

同一个行为，使用不同的对象获得不同的状态

5.1 说明

• 多态常作用在继承关系上
  
  
  
  • 函数（方法）形参声明接收父类对象，实际传入子类对象进行工作
    
  
  

5.2 抽象类（接口）

抽象类：含有抽象方法的类
抽象方法：没有具体实现的方法（pass）

• 抽象类是对子类的一种软性约束，要求子类必须实现父类的一些方法
  
• 配合多态使用，获得不同的工作状态
  
• 多用于做顶层设计（设计标准），以便子类具体实现
  

• 父类用来确定有哪些方法（类似于标准）
  
• 具体的方法实现，由子类自行决定
  

1. while 条件:
2.         ...

复制代码

十六、Python 操作数据库

1. 安装与连接

• 在 Python 中使用pymysql来操作 MySQL
  

1. while guess != 8:
2.         temp = input("猜错了，请重新输入：")
3.         guess = int(temp)
4.        
5.         if guess == secret:
6.                 print("猜中了！")
7.         else:
8.                 if guess > secret:
9.                         print("猜大了")
10.                 else:
11.                         print("猜小了")

复制代码

• 连接
  

1. while 条件1:
2.         ...
3.         while 条件2:
4.         ...

复制代码

2. 执行SQL语句

• 执行非查询性质的 SQL 语句（创建表等...）
  
• 执行查询性质的 SQL 语句
  
  
  
  • fetchall()得到全部的查询结果封装入元组内
    
  
  

1. print("hello", end = '')
2. print("world", end = '')

复制代码

3. 提交

pymysql 库修改数据库时，需要通过链接对象的 commit 成员方法来进行确认，只有确认后，修改才生效

3.1 手动提交

1. i = 1
2. while i <= 9:
3.     j = 1
4.     while j <= i:
5.         print(f"{j} * {i} = {j * i}\t", end='')
6.         j += 1
7.     i += 1
8.     print()

复制代码

示例：

1. # 导包from pymysql import Connection# 获取到MySQL数据库的链接对象conn = Connection(        host='localhost',        # 主机名（或IP地址）        port=3306,                        # 端口，默认3306        user='root',                # 账户名        password='root'                # 密码)# 获取游标对象cursor = conn.cursor()# 选择数据库conn.select_db("world")# 执行sqlcursor.execute("insert into student values(1001, '周杰伦', 31, '男')")# 手动提交i = 1
2. while i <= 9:
3.     j = 1
4.     while j <= i:
5.         print(f"{j} * {i} = {j * i}\t", end='')
6.         j += 1
7.     i += 1
8.     print()# 关闭到数据库的链接conn.close()

复制代码

3.2 自动提交

• 在获取到MySQL数据库的链接对象时设置
  

1. name = "itheima"
2. # for 循环处理字符串
3. for x in name:
4.         print(x)

复制代码

示例：

1. conn = Connection(        host='localhost',        # 主机名（或IP地址）        port=3306,                        # 端口，默认3306        user='root',                # 账户名        password='root'                # 密码        name = "itheima"
2. # for 循环处理字符串
3. for x in name:
4.         print(x)                # 设置自动提交)

复制代码

十七、闭包

1. 案例引入

1. for x in range(5, 10):
2.         print(x)

复制代码

• 尽管功能实现是可以的，但是仍有问题
  
  
  
  • 代码在命名空间上（变量定义）不够干净、整洁
    
  • 全局变量有被修改的风险
    
  
  

2. 语法定义

• 定义双层嵌套函数，内部函数可以访问外部函数的变量，且外部函数返回了内部函数
  
• 将这个使用外部函数变量的内部函数称为闭包
  

• 优化后的代码如下
  

1. # 必须先定义后使用
2. def 函数名(传入参数):
3.         函数体
4.         return 返回值
6. 函数名(参数)

复制代码

3. 简单闭包

1. def say_hi():
2.         print("hi")
4. result = say_hi()
5. print(f"无返回值函数，返回的内容是：{result}")                        # None
6. print(f"无返回值函数，返回的内容类型是：{type(result)}")  # <class 'NoneType'>

复制代码

4. 修改外部函数变量的值

• 使用nonlocal关键字修饰外部函数的变量
  
• nonlocal关键字修饰变量后标识该变量是上一级函数中的局部变量，如果上一级函数中不存在该局部变量，nonlocal位置会发生错误（最上层的函数使用nonlocal修饰变量必定会报错）
  

1. return None

复制代码

5. 优缺点

• 优点
  
  
  
  • 不定义全局变量也可以让函数持续访问和修改外部变量
    
  • 闭包函数引用的外部变量是外层函数的内部变量，作用域封闭难以被误操作修改
    
  
  
• 缺点
  
  
  
  • 内部函数持续引用外部函数的值，导致这部分内存空间不被释放，一直占用内存
    
  
  

6. 装饰器

• 创建一个闭包函数，在闭包函数内调用目标函数【装饰器就是一种闭包】
  
• 在不改动目标函数的前提下，为目标函数增加新功能
  

• 引入
  

1. def func(x, y):
2.         """
3.         函数说明
4.         :param x: 形参x的说明
5.         :param y: 形参y的说明
6.         :return: 返回值的说明
7.         """

复制代码

• 希望给 sleep 函数增加一个功能
  
  
  
  • 调用 sleep 前输出：我要睡觉了
    
  • 调用 sleep 后输出：我起床了
    
  
  
• 下列写法也可以实现，但不推荐
  

1. num = 100
3. def testA():
4.         print(num)
6. def testB():
7.         global num
8.         num = 200
9.         print(num)
11. testA()
12. testB()
13. print(f"全局变量 num = {num}")

复制代码

• 优化（一般写法）
  

1. def outer(func):    def inner():        print("我要睡觉了")        func()        print("我起床了")            return innerdef func(x, y):
2.         """
3.         函数说明
4.         :param x: 形参x的说明
5.         :param y: 形参y的说明
6.         :return: 返回值的说明
7.         """fn = outer(sleep)fn()

复制代码

• 装饰器的语法糖写法
  
  
  
  • 使用@outer，定义在目标函数之上
    
  
  

1. def outer(func):    def inner():        print("我要睡觉了")        func()        print("我起床了")            return inner@outerdef func(x, y):
2.         """
3.         函数说明
4.         :param x: 形参x的说明
5.         :param y: 形参y的说明
6.         :return: 返回值的说明
7.         """sleep()

复制代码

十八、设计模式

• 设计模式是一种编程套路，可方便程序开发
  
• 最常见的设计模式是面向对象
  
• 此外还有许多设计模式
  
  
  
  • 单例模式、工厂模式
    
  • 建造者、责任链、状态、备忘录、解释器、访问者、观察者、中介、模板、代理模式等等
    
  
  

1. 单例模式

• 确保某一个类只有一个实例存在，并提供一个访问它的全局访问点
  
  
  
  • 节省内存以及创建对象的开销
    
  
  
• 实现
  

1. def user_info(name, age, gender):
2.         print(f"您的名字是：{name}, 年龄是：{age}, 性别是：{gender}")
3.        
4. user_info(name = 'TOM', age = 20, gender = '男')
5. # 可不按照固定顺序
6. user_info(age = 20, name = 'TOM', gender = '男')
7. # 可与位置参数混用
8. user_info("小明", age = 20, gender = "男")

复制代码

2. 工厂模式

• 当需要大量创建一个类的实例时，可以使用工厂模式
  
• 基于工厂提供的方法来创建对象
  

• 原始代码
  

1. def user_info(name, age, gender='男'):
2.         print(f"您的名字是：{name}, 年龄是：{age}, 性别是：{gender}")
3.        
4. user_info('TOM', 20)
5. user_info('Rose', 18, '女')

复制代码

• 优化后的代码
  
  
  
  • 使用工厂类的get_person()方法去创建具体的类对象
    
  
  

1. def user_info(*args):
2.         print(args)
4. user_info('TOM')
5. user_info('TOM', 18)

复制代码

• 优点
  
  
  
  • 大批量创建对象时有统一的入口，易于代码维护
    
  • 当发生修改，仅修改工厂类的创建方法即可
    
  • 符合现实世界的模式，即由工厂来制作产品（对象）
    
  
  

十九、多线程

1. 进程、线程

• 进程：程序在操作系统内运行，即成为一个运行进程，并分配进程ID方便系统管理
  
• 线程：进程内部可以有多个线程，程序的运行本质上是由进程内部的线程在实际工作
  
• 类比：进程好比一家公司，而线程为公司的员工
  
• 进程之间内存隔离，即不同的进程拥有各自的内存空间
  
• 线程之间内存共享，线程属于进程，一个进程内的多个线程之间共享这个进程所拥有的内存空间
  

2. 并行执行

同一时间做不同的工作

• 多任务并行执行：不同的程序同时运行
  
• 多线程并行执行：一个进程内的多个线程同时运行
  

3. 多线程编程

3.1 threading 模块

1. def user_info(**kwargs):
2.         print(kwargs)
3.        
4. user_info(name = 'TOM', age = 18, id = 110)

复制代码

3.2 示例1

1. def demo(*args, **kwargs):
2.         print(args)
3.         print(kwargs)
4.        
5. # 元组、字典变量
6. gl_nums = (1, 2, 3)
7. gl_dict = {"name": "小明", "age": 18}
9. demo(*gl_nums, **gl_dict)        # 等价于demo(1, 2, 3, "name": "小明", age=18)

复制代码

3.3 示例2

1. def test_func(compute):
2.         result = compute(1, 2)
3.         print(f"compute参数的类型是：{type(compute)}")
4.         print(f"计算结果是：{result}")
5.        
6. def compute(x, y):
7.         return x + y
8.        
9. test_func(compute)

复制代码

二十、网络编程

1. Socket

socket（简称套接字）是进程之间通信的工具，负责进程之间的网络数据传输

2. 客户端和服务端

• Socket 服务端：等待其他进程的连接、可接收发来的消息、可回复消息
  
• Socket 客户端：主动连接服务端、可以发送消息、可以接收回复
  

2.1 服务端

• 创建 socket 对象，并绑定 ip 地址和端口
  
• 服务端开始监听端口
  

1. lambda 传入参数: 函数体

复制代码

• 接收客户端连接，获得连接对象
  

1. def test_func(compute):
2.         result = compute(1, 2)
3.         print(result)
5. test_func(lambda x, y: x + y)

复制代码

• 回复与发送消息
  

1. 变量名 = [元素1, 元素2, 元素3, ...]
3. # 定义空列表
4. 变量名 = []
5. 变量名 = list()

复制代码

具体示例：

1. class Student:
2.        
3.         def add(self, x, y):
4.                 return x + y

复制代码

2.2 客户端

1. student = Student()
2. num = student.add(1, 2)

复制代码

二十一、正则表达式

一种字符串验证的规则，通过特殊的字符串组合来确定规则

1.Python re模块

方法说明match(匹配规则, 被匹配字符串)从被匹配字符串开头进行匹配，匹配第一个命中项（含匹配的信息），匹配失败返回空search(匹配规则, 被匹配字符串)全局匹配，从前往后找，找到第一个后就停止，不会继续向后；若找不到返回Nonefindall(匹配规则, 被匹配字符串)全局匹配，找出全部匹配项；找不到返回空 list示例1：

1. myList = [1, 2, 3]
3. # 查询
4. index = myList.index(2)
5. print(f"元素2在列表中的下标索引值是：{index}")    # 结果：1
7. # index = myList.index(4)   # 报错
8. # print(f"元素4在列表中的下标索引值是：{index}")
10. # 修改
11. myList[0] = -1
12. print(f"列表被修改元素值后，结果是：{myList}")    # 结果：[-1, 2, 3]
14. # 插入
15. myList.insert(1, 6)
16. print(f"插入666后的结果：{myList}")    # 结果：[-1, 6, 2, 3]
18. # 追加
19. # 方式1：append
20. myList.append(4)
21. print(f"append追加单个元素：{myList}")    # 结果：[-1, 6, 2, 3, 4]
22. myList.append([4, 5, 6])
23. print(f"append追加列表：{myList}")        # 结果：[-1, 6, 2, 3, 4, [4, 5, 6]]
24. # 方式2：extend
25. myList.extend([4, 5, 6])
26. print(f"extend追加列表：{myList}")        # 结果：[-1, 6, 2, 3, 4, [4, 5, 6], 4, 5, 6]
28. # 删除
29. # 方式1：del
30. del myList[5]
31. print(f"del删除：{myList}")        # 结果：[-1, 6, 2, 3, 4, 4, 5, 6]
32. # 方式2：pop
33. element = myList.pop(0)
34. print(f"pop删除：{myList}")        # 结果：[6, 2, 3, 4, 4, 5, 6]
35. # 删除某元素在列表中的第一个匹配项
36. myList.remove(6)
37. print(f"remove删除：{myList}")        # 结果：[2, 3, 4, 4, 5, 6]
39. # 统计某元素在列表内的数量
40. print(f"count：{myList.count(4)}")                # 结果：2
42. # 统计列表内有多少元素
43. print(f"len：{len(myList)}")                # 结果：6
45. # 清空列表内容
46. myList.clear()
47. print(f"清空列表：{myList}")        # 结果：[]

复制代码

示例2：

1. index = 0
2. while index < len(列表):
3.         元素 = 列表[index]
4.         对元素进行处理
5.         index += 1

复制代码

2. 元字符匹配

2.1 单字符匹配

字符功能.匹配任意1个字符（除了\n），\.匹配点本身[]匹配 [] 中列举的字符\d匹配数字，即0-9\D匹配非数字\s匹配空白，即空格、tab\S匹配非空白\w匹配单词字符，即a-z、A-Z、0-9、_\W匹配非单词字符2.2 数量匹配

字符功能*匹配前一个规则的字符出现0至无数次+匹配前一个规则的字符出现至少1次?匹配前一个规则的字符出现0次或1次匹配前一个规则的字符出现m次匹配前一个规则的字符出现至少m次匹配前一个规则的字符出现m至n次2.3 边界匹配

字符功能^匹配字符串开头$匹配字符串结尾\b匹配一个单词的边界\B匹配非单词边界2.4 分组匹配

字符功能|匹配左右任意一个表达式()将括号中字符作为一个分组2.5 示例

1. for element in my_list:
2.         print(f"列表的元素有：{element}")

复制代码

二十二、递归

方法（函数）自己调用自己

1. 变量名 = (元素1, 元素2, ...)
3. # 定义空元组
4. 变量名 = ()                # 方式1
5. 变量名 = tuple()        # 方式2
7. # 定义只有一个元素的元组，后面必须有逗号，否则就不是元组类型
8. t = ('hello', )

复制代码

• os 模块三个基础方法
  

1. t1 = (1, 2, ['itheima', 'itcast'])
2. t1[2][1] = 'best'
3. print(t1)                # 结果：(1, 2, ['itheima', 'best'])

复制代码

1. 案例：递归找文件

1. # ,拼接
2. from string import Template
4. print('str1：', 'hello', 'world')
6. # +拼接
7. str2 = 'hello' + '12'
8. print(f"str2：{str2}")
10. # 空格拼接
11. str3 = 'hello' 'world'
12. print(f"str3：{str3}")
14. # 换行自动拼接
15. print("str4："
16.       "hello"
17.       "world")
19. # 乘法*拼接
20. str5 = 'a-' * 10
21. print(f"str5：{str5}")  # a-a-a-a-a-a-a-a-a-a-
23. # str.join()
24. myList = ['你', '好', '世', '界']
25. str6 = '-'.join(myList)
26. print(f"str6：{str6}")
28. # string模块的Template对象
29. t = Template('${s1} ${s2}！')
30. str7 = t.safe_substitute(s1='hello', s2='world')
31. print(f"str7：{str7}")

复制代码

2. 注意点

• 注意退出条件，否则容易变成无限递归
  
• 注意返回值的传递，确保从最内层，层层传递到最外层
  

二十三、json文件

• json 基于文本，独立于语言的轻量级的数据交换格式，本质上是一个带有特定格式的字符串
  
  
  
  • 基于文本：是一个文本文件
    
  • 独立于语言：不是某个语言特有的，每种编程语言都可以使用
    
  • 轻量级：相同数据，相比于其他格式，占用的大小较小
    
  • 数据交换格式：后端程序员给前端的数据（json、html、xml）
    
  
  
• 可以直接使用read()和write()方法去操作文件，但是不方便，所以使用 json 文件自身特有的读取和写入方法
  
• 在做测试时，常将测试数据定义为 json 文件格式，使用代码读取 json 文件，即读取测试数据，进行传参（参数化）
  
• JSON 作用：使不同的语言能够互相传递数据
  

1. 语法

• 主要数据类型：对象{}和数组[]，类似 Python 中的字典和列表（可相互嵌套）
  
• 一个 json 文件是一个对象或数组
  
• json 中的对象由键值对组成，每个数据之间用逗号隔开，最后一个数据后不用写逗号
  
• json 中的字符串必须用""
  
• json 中的其他数据类型
  
  
  
  • 数字 ---> int float
    
  • 字符串 string ---> str
    
  • 布尔 true、false ---> True、False
    
  • null ---> None
    
  
  
• 示例：
  

1. name = "黑马程序员"
2. msg1 = "学IT就来%s" % name        # %s是占位符
3. print(msg1)
5. # 多个变量要用括号括起来，并按照占位的顺序填入
6. tel = 123456789
7. msg2 = "我的名字：%s, 电话：%s" % (name, tel)        # tel的占位符可用%d
8. print(msg2)

复制代码

2. 读取 json 文件

• json.load(文件对象)，返回的是字典或列表
  

1. f"内容{变量}"

复制代码

3. 换成 [(), (), ()] 格式

某网站的测试数据如下，需求：提取 json 文件中的用户名、密码和预期结果，组成：[(), (), ()] 格式（自动化参数化需要的数据格式）

1. name = "传智播客"
2. set_up_year = 2006
3. stock_price = 19.99
4. print(f"我是{name}，我成立于：{set_up_year}，我今天的股票价格是：{stock_price}")

复制代码

4. json 的写入

f.write(字符串)不能将Python的列表和字典作为参数传递，如果要写入 json 文件，则使用 json 特定的方法

• json.dump(Python中的数据类型, 文件对象)
  

1. 内容.format(变量)

复制代码

5. Python 数据和 Json 数据的相互转化

1. # {}中数字表示使用第几个参数
2. message_content = """
3. 金{0}贺岁，欢乐祥瑞。
4. 金{0}敲门，五福临门。
5. 给{1}及家人拜年啦！
6. """.format(year, name)
8. # 使用变量占位
9. message_content = """
10. 金{current_year}贺岁，欢乐祥瑞。
11. 金{current_year}敲门，五福临门。
12. 给{receiver_name}及家人拜年啦！
13. """.format(current_year = year, receiver_name = name)

复制代码

注：如果有中文，带上ensure_ascii=False来确保中文正常转换
示例：

1. gpa_dict = {"Tom": 3.251, "Amy": 3.864, "John": 4.105}
3. for name, gpa in gpa_dict.items():
4.         print("{0}你好，你当前的绩点为：{1:.2f}".format(name, gpa))
5.    
6. for name, gpa in gpa_dict.items():
7.         print(f"{name}你好，你当前的绩点为：{gpa:.2f}")

复制代码

来源:https://www.cnblogs.com/iRuriCatt/p/18583113
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！