python 基础

python 基础 X-mind 思维导图
点此下载

python 基础_第1张图片


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、一条语句默认一行,多行语句在一行可用分号 ; 隔开
9print() 默认一行,多个 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 不能为 listset,可为 tuple
3、key 和 value 都不能为 null

字典:d={
     key:value}
字典元素:d[key]
元素个数:len(d)

新增或修改:d[key]=value,不存在则新增,存在则修改
删除 deldel 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 '类型'>intfloatstrlisttuplesetdict
判断数据类型是否相等:
	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. 语句

1if 判断语句
	格式:if 条件语句: 符合条件  -  elif 条件语句: 符合条件  -  else: 不符合条件

2for 循环语句
	格式:for 条件语句: 符合条件  -  else: 不符合条件
	(1for i in range(取值范围)
		取值范围:[取值范围)2for i in 多元素数据
		取值范围:所有元素
		for i in 多元素数据[索引1:索引2:步长]3for i in range(0,len(多元素数据)) 
		取值范围: [0,len(多元素数据))

3while 循环语句
	格式:while 条件语句: 符合条件  -  else: 不符合条件
	while True:死循环

4continue 语句:跳过后面代码,进入下一次循环
5break 语句:跳出循环
	continuebreak :用于 forwhile 循环

6pass 语句:占位、提示
	作用:一般用于占位,保证程序结构的完整性
	编写程序时,部分代码尚未完成,用 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、常用包
	(1import time;
		time.sleep(3) # 休眠3秒
		time.strftime('%Y-%m-%d %H-%M-%S',time.localtime()) # 格式化本地时间2import calendar;
		calendar.calendar(2021) # 显示2021年的日历
		calendar.month(2021,3) # 显示2021年3月的日历
		calendar.isleap(2021) # 判断闰年3import 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、读取内容
	(1file.read()
		类型为 str
		file.read() 读所有的数据
		file.read(5):从当前焦点读5个字符
	(2file.readline()
		类型为 str
		从当前焦点读一行数据
	(3file.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:
# 执行语句,最后都会被执行

你可能感兴趣的:(Alance,软件测试进阶之路,Python学习日志,python)