python 基础
python 基础 X-mind 思维导图
点此下载
1. python 特征
- 面向过程语言
- 面向对象语言（封装、继承、多态）
2. 语法规则
- 命名规则
- 字符编码
- 基本语法
3. 运算符
- 数字运算符
- 比较运算符
- 逻辑运算符
- 赋值运算符
- 位运算符
- 成员运算符（in 、not in）
- 身份运算符（is、is not）
4. 数据类型
- 数值型 Number
- 字符串 String
- 列表 List
- 元组 Tuple
- 集合 Set
- 字典 Dict
5. 变量
- 普通变量 variable
- 全局变量 global variable
- 受保护变量 protected variable
- 私有变量 private variable
6. 语句
- if 判断语句
- for 循环语句
- while 循环语句
- continue 语句
- break 语句
- pass 语句
7. 方法
- 定义方法
- 参数类型（无参数、固定参数、可选参数、可变参数）
- 返回值
- 调用方法（内部调用、外部调用）
8. 类
- 定义
- 创建类
- 属性
- 方法（普通方法、受保护方法、私有方法）
- 构造函数 init
- 对象 object
- 继承
- 常用包（time、calendar、random）
9. 文件
- 9.1 文件 IO
- 9.2 数据库 IO
10. 异常处理
- Except 作用和用法
1. python 特征
- 面向过程语言：C语言
特点：编写简单，是面向对象的基础，但重复定义，且难以维护 - 面向对象语言：C++、java、python、php、ruby
特点：容易阅读，易复用、易扩展、易维护，但性能低
特征：封装、继承、多态 - 封装：将事物抽象为类，隐藏内部属性和方法，对外只暴露接口，实现代码模块化
- 继承：子类可以直接使用父类的属性和方法，而无需再次编写，实现代码重用
- 多态：子类以其他方式（覆盖、重载）实现父类方法，可实现接口重用
2. 语法规则
- python 文件后缀： *.py
- python 命名规则
1、python 文件：小写字母、_下划线
2、变量命名：由数字、字符、_下划线组成，数字不能开头，下划线开头有特殊意义，避开关键字
3、函数命名：由数字、字符、_下划线组成，数字不能开头，下划线开头有特殊意义，避开关键字
4、类命名：首字母大写，由数字、字符、_下划线组成，数字不能开头，下划线开头有特殊意义，避开关键字
- linux py文件开头
#!/etc/bin/python
#!/usr/bin/env python
- 字符编码
# coding=utf-8
# -*- coding: utf-8 -*-
- 基础语法
1、区分大小写
2、区分代码块缩进
3、单行注释 #
4、多行注释 ''' '''、""" """
5、定义变量不需要声明类型
6、字符串需加引号：''、""、''' '''、""" """
7、三单引号和三双引号无需加换行符 \n 和转义符 \
8、一条语句默认一行，多行语句在一行可用分号 ; 隔开
9、print() 默认一行，多个 print() 在一行可用 end='' 连接，默认 end='\n'
10、续行符：\ ，换行符：\n
11、null 与双单引号 '' 的区别：双单引号 '' 占空间，null 不占空间
12、转义字符：\ +字符，转为普通字符
3. 运算符
- 数字运算符：+、-、*、/、%（模）、
**（幂：a**b）、// （整除，取最小值） - 比较运算符：>、<、>=、<=、!=、==
- 逻辑运算符：and、or、not
- 赋值运算符：=、+=、-=、*=、/=、%=、
**=、//= - 位运算符：&、|、^、~、<<、>>
- 成员运算符：in、not in
- 身份运算符：is、is not，是否引用同一个对象，或者是否同一种数据类型
- 优先级由高到低：数字运算符、位运算符 > 比较运算符（比较大于大于） > 赋值运算符 > 身份运算符 > 成员运算符 > 逻辑运算符
4. 数据类型
python 数据类型：数值型、字符串、列表、元组、集合、字典
- 数值型 Number
数值型：整型 int 、浮点型 float
- 字符串 String
字符长度：len(s)
某个字符：s[索引]
某段字符：s[索引1:索引2:步长]
正序：[::1]，步长位正数
倒序：[::-1]，步长位负数
方向：索引方向需与步长一致，否则结果为空
取值范围：[索引1，索引2)，包含索引1，不包含索引2
字符串拼接
s * n：重复拼接 s 字符串 n 次
s1 + s2：+ 将字符串 s1 和 s2 拼接
字符串大小
不同类型不能比较大小
s1 > s2：按位比较大小（ASII）
字符串内容为纯数字，才能转型位数值型
- 列表 List
列表 List 的特点：有序可编辑，元素可重复
列表：ls=[]
列表元素：ls[索引]
元素个数：len(ls)
最大值：max(ls)
最小值：min(ls)
追加 append：ls.append(元素)
插入 insert：ls.insert(索引 , 元素)
移除 remove：ls.remove(元素)，重复元素默认移除第一个
移除 del + ls[索引]
移除单个：del ls[索引]
移除多个：del ls[索引1:索引2:步长]
位置反转 reverse
ls.reverse()：倒序，与 ls[::-1] 结果一致
排序 sort
升序：ls.sort()，或 ls.sort(reverse=False)
降序：ls.sort(reverse=True)
- 元组 Tuple
元组 Tuple 的特点：有序不可编辑，元素可重复
元组：t=()
元组元素：t[索引]
元素个数：len(t)
最大值：max(t)
最小值：min(t)
- 集合 Set
集合 Set 的特点：无序可编辑，元素不重复
集合：s={
}
元素元素：s[索引]
元素个数：len(s)
最大值：max(s)
最小值：min(s)
新增 add：s.add(元素)
移除 remove：s.remove(元素)
- 字典 Dict
字典 Dict 的特点：
1、无序可编辑，key 不重复
2、key 不能为 list 和 set，可为 tuple
3、key 和 value 都不能为 null
字典：d={
key:value}
字典元素：d[key]
元素个数：len(d)
新增或修改：d[key]=value，不存在则新增，存在则修改
删除 del：del d[key]
查看 keys：d.keys()，相当于 list(d)
查看 values：d.values()
- 类型转换
int()、float()、str()、list()、tuple()、set()
- 输出数据类型
print(输出数据)
%d：整型
%f：浮点数（默认6位，缺补0）
%s：字符串
%0.2f、%.2f：小数点后保留两位
a=1.23456789
print('这是浮点数：%0.2f' % a)
# 结果为：这是浮点数：1.23
5. 变量
- 变量类型
变量类型：普通变量、全局变量、受保护变量、私有变量
1、普通变量 variable
2、全局变量 global variable
3、受保护变量 protected variable
单下划线：_variable，外部不能调用，内部调用 self._variable
双下划线（多下划线）：__variable，跨文件导入 * 时，调用会出错
4、私有变量 private variable
查看变量类型：type(变量)
<class '类型'>：int、float、str、list、tuple、set、dict
判断数据类型是否相等：
type(变量) is 类型
type(变量) == 类型
判断变量内容是否相等：== 或 !=
返回变量存储变量：id(变量)
- 变量赋值
1、单个赋值：
v = value
2、多个赋值：
v1,v2 = value1,value2
v1 = v2 =value
3、交换赋值：
v1,v2 = v2,v1
或 v1 = temp, v1 = v2, v2 = temp
6. 语句
1、if 判断语句
格式：if 条件语句: 符合条件 - elif 条件语句: 符合条件 - else: 不符合条件
2、for 循环语句
格式：for 条件语句: 符合条件 - else: 不符合条件
（1）for i in range(取值范围)
取值范围：[取值范围)
（2）for i in 多元素数据
取值范围：所有元素
for i in 多元素数据[索引1:索引2:步长]
（3）for i in range(0,len(多元素数据))
取值范围： [0,len(多元素数据))
3、while 循环语句
格式：while 条件语句: 符合条件 - else: 不符合条件
while True：死循环
4、continue 语句：跳过后面代码，进入下一次循环
5、break 语句：跳出循环
continue 与 break ：用于 for 和 while 循环
6、pass 语句：占位、提示
作用：一般用于占位，保证程序结构的完整性
编写程序时，部分代码尚未完成，用 pass 作为标记来提示以后完成
7. 方法
1、定义方法
def function(参数):
方法被调用才执行，重名调用最后一个
2、参数类型
- 无参数
def function():
- 固定参数
单个参数：def function(a):
多个参数：def function(a,b,c):
固定+可选、固定+可变，固定参数必须在前面
- 可选参数
def function(a=123):
不传参使用默认值，传参使用传来的值
- 可变参数
def function(*a):
类型为元组 tuple，不传参为空元组，可传单个或多个参数
3、返回值
方法没写 return，默认为 return None
return 代表结束，return 后面语句不执行
4、调用方法
- 本文件调用方法（内部调用）
function()
- 跨文件调用方法（外部调用）
（1）导入文件函数
import 完整路径.文件名
from 完整路径.文件名 import functions
from 完整路径.文件名 import * ：导入该文件的所有方法
（2）调用方法 function()
完整路径.文件名.function()
（3）不执行引入的可执行代码
被引入文件的可执行代码都会执行
若不想被执行，在代码前添加，注意双下划线、双等号：
if __name__=='__main__':
8. 类
1、定义：对同一类事物的共同属性和功能的概括
2、创建类：class cl:
3、属性
类变量：所有对象都有的属性
实例变量：对象特有的属性
4、方法：第一个默认参数为 self，不能传值
方法类型：
（1）普通方法：def function():
（2）受保护方法 protected：
单下划线：def _function()
外部不能调用，内部调用 self.__function()
（3）私有方法 private：
双下划线、多下划线：def __function()
跨文件导入 * 时，调用会出错
5、构造函数 init
def __init__(self):
调用类就是在调用构造函数
不能写 return ，默认返回对象
没有定义构造函数，系统会默认构建
没有定义的属性或方法，调用时会报错
6、对象 object
创建对象：oj=cl()
调用方法：oj.function()
7、继承
（1）定义
子类继承父类的属性和方法：class son(dad):，class son(dad1,dad2,...):
子类可继承多个父类，继承最多三层（爷父子）
不能互为父子，不能逻辑关系混乱
（2）构造方法
如果没有构造方法，系统默认创建
继承顺序：子类 > 父类1（或父类1的父类） > 父类2（或父类1的父类）...
（3）同名属性、方法
如果子类和父类都没有同名属性或方法，则报错
继承顺序：子类 > 父类1（或父类1的父类） > 父类2（或父类1的父类）...
（4）覆盖 override 、重写 overwrite
子类与父类的方法名相同，参数类型和个数都相同
（5）重载 overloading
子类与父类的方法名相同，参数类型或个数不同
（6）通过对象调用父类属性和方法
super(子类,对象).父类的属性或方法
（7）判断类 a 是否为类 b 的子类
issubclass(a,b)
（8）判断对象 oj 是否为类 cl 对象
insinstance(oj,cl)
8、常用包
（1）import time;
time.sleep(3) # 休眠3秒
time.strftime('%Y-%m-%d %H-%M-%S',time.localtime()) # 格式化本地时间
（2）import calendar;
calendar.calendar(2021) # 显示2021年的日历
calendar.month(2021,3) # 显示2021年3月的日历
calendar.isleap(2021) # 判断闰年
（3）import random;
random.randint(1,9) # 取1~9的随机数
9. 文件
9.1 文件 IO
1、打开文件
file=open('路径/文件名','打开方式')
2、打开方式
w：写
a：追加
r：只读
+：可读写
W+：不存在文件则新建，存在则覆盖所有内容，焦点在第一位
a+：不存在文件则新建，存在则追加内容，焦点在最后
如果想读所有数据，先要把焦点定在首位：file.seek(0)
r+：不存在文件则报错，存在则从左到右覆盖内容，焦点在第一位
3、读取内容
（1）file.read()
类型为 str
file.read() 读所有的数据
file.read(5)：从当前焦点读5个字符
（2）file.readline()
类型为 str
从当前焦点读一行数据
（3）file.readlines()
类型为 list
从当前焦点读所有数据
4、返回当前焦点位置
file.tell() # 返回数值
5、跳转到某焦点位置
file.seek(a) # a 为数值
6、关闭文件
file.close()
7、举栗子：
# file=open('a.txt','w+')
# file.write('1234')
# file.close()
# file=open('b.txt','a+')
# file.write('abcd')
# file.seek(0)
# print(file.read())
# file.close()
file=open('b.txt','r+') # 打开文件
file.write('qq\'qq') # \ 转义符，将特殊字符 ' 转义为普通字符
a=file.read(3) # read()，readline()，readlines()
print(a,type(a)) # type: str,list
b=file.tell() # 返回当前焦点位置，为数值
file.seek(b) # 跳转到某焦点位置
file.close() # 关闭文件
9.2 数据库 IO
1、导入 pymysql
import pymysql
2、连接数据库
conn=pymysql.connect(host,user,password,db)
3、创建游标
cursor=conn.cursor()
4、执行sql语句
cursor.execute(sql)
5、获取单个、多个、所有数据，类型为元组 tuple
cursor.fetchone()
获取第一条数据，无数据返回 None
cursor.fetchmany(n)
获取前 n 条数据，返回一维元组，无数据返回 ()
cursor.fetchall()
获取所有数据，返回二维元组，无数据返回 ()
6、修改数据需提交
除了查询外，insert、update、delete 等修改数据后，则需要提交，才能成功保存到数据库
conn.commit()
7、关闭游标
cursor.close()
8、关闭数据库连接
conn.close()
9、举栗子：
# 导入 pymysql
import pymysql
# 连接数据库
conn=pymysql.connect(host='localhost',user='root',passwd='',db='school_50',port=3306,charset='utf8')
# 创建游标
cursor=conn.cursor()
# 执行语句
cursor.execute('select * from student;')
# sql= 'insert into student values("%s","%s","%s","%s")' % ('09','澳洲','1994-02-28','女')
# num = cursor.execute(sql) # 执行结果统计数量
# 获取数据，fetchone，fetchmany,fetchall()
list=cursor.fetchmany()
print(type(list),list)
# for i in list:
# print(i)
# 提交修改
conn.commit()
# 关闭游标
cursor.close()
# 关闭数据库
conn.close()
10. 异常处理
- Except 作用和用法
Except 作用：处理异常
Except用法：
try:
# 执行语句
# 捕获异常进入 except 块
# 若无异常进入 else 块
except error as e:
# 处理异常
# 一个 except 块可有多个异常
# try 块只有一个，except 块可有多个
else：
# 执行语句
finally:
# 执行语句，最后都会被执行