本篇博客是对python中一些基础语法，编程知识的整理。因为是在自己的认知基础上所写，写得比较简略。部分知识也并未深入探讨学习，看看就好
文章目录
变量的命名规则
应满足以下条件：
- 由数字、字母、下划线组成，但是不能以数字开头
- 不能使用python 的关键字
如何查看python的关键字呢？使用以下代码：
import keyword
print(keyword.kwlist)
结果：
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def',
'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
- 变量命名尽量做到见名知意
变量的命名风格：请使用下划线命名风格，例如：regist_page, python_grammer
随机数
在python中有一个内置的随机数模块random，可以用来生成随机数，常用两个方法：
- random.random() 用来生成一个 [0, 1) 的随机数
- random.randint(a, b) 用来生成一个 [a, b] 的随机数
- random.uniform(a,b) 用来生成一个[a，b]的随机浮点数
示例代码如下：
import random
for i in range(5):
a = random.random()
b = random.randint(1, 100)
print(F'第一个随机数为{a}，第二个随机数为{b}')
结果：
第一个随机数为0.6063628302810828，第二个随机数为3
第一个随机数为0.6098753178007876，第二个随机数为87
第一个随机数为0.20760884641477861，第二个随机数为93
第一个随机数为0.33096649687847035，第二个随机数为3
第一个随机数为0.8333777799681839，第二个随机数为37
需求：如何生成指定范围的浮点数？
解决方案：随机生成的整数+随机生成的小数。注意边界值
字符串
字符串类型就是str类型，通常用单引号、双引号、或者三引号包起来。
单引号和双引号没有任何区别，都是表示一行字符串
三引号（三个单引号和双引号是一样的）可用来表示多行字符串
空字符串：只有引号，引号中没有任何内容（连空格键都没有）
字符串的拼接：
- 使用加号进行拼接：
s1 = 'a' s2 = 'b' s3 = s1 + s2结果是a b - 使用 join 进行拼接：
s4 = ' and '.join((s1,s2)),结果是a and b
字符串常用方法
其中某些方法的应用见下方代码：
str = 'Python study more and more hard'
print(str.find('u')) # 结果 ：9
print(str.count('more')) # 结果 ：2
print(str.split(' ')) # 结果 ：['Python', 'study', 'more', 'and', 'more', 'hard']
print(str.replace('more','one')) # 结果：Python study one and one hard
print(str.upper()) # 结果： PYTHON STUDY MORE AND MORE HARD
print('AABB'.lower()) # 结果： aabb
字符串转义
# 换行符
print('aaaaa\nbbbb') # 结果： aaaaa 换行 bbbb
# 制表符，一般是4个空格
print('aaaaa\tbbbb') # 结果： aaaaa bbbb
# r表达式，用来关闭字符串转义
print(r'D:\Python dev\test\test.py') # 结果：D:\Python dev\test\test.py
类型转换
数据类型之间的转换，用代码来进行描述：
a = 11
b = 13.890
c = True
d = False
# 浮点数和布尔值转化为整数
print(int(b)) # 结果 = 13，将浮点数小数部分直接去掉
print(int(c)) # 结果 = 1
print(int(d)) # 结果 = 0
# 整数和布尔值转换为浮点数
print(float(a)) # 结果 = 11.0
print(float(c)) # 结果 = 1.0
print(float(d)) # 结果 = 0.0
# 整数和浮点数转化为布尔值(只要不是0，其他的布尔值都为1)
print(bool(a)) # 结果 = True
print(bool('aaa')) # 结果 = True
print(bool(0)) # 结果 = False
# 字符串转换为数值：整数或浮点数（前提：字符串中只有数字，不能存在字符）
print(int('85')) # 结果 = 85
print(float('12.56')) # 结果 = 12.56
print不换行输出
print(‘XXXXXX’, end="")
格式化输出的几种方式
format 格式化输出：
该函数能够将字符串当成一个模板，通过传入的参数进行格式化，并且使用大括号 {} 作为特殊字符胎体 ‘%’
其中上面的左对齐右对齐和居中对齐代码如下，还能在<,>,^前加上字符，表示用该字符填充其他的部分。
print('默认的：{:10}'.format('aaa')) # 结果： 默认的：aaa
print('左对齐的：{:<10}'.format('aaa')) # 结果：左对齐的：aaa
print('右对齐的：{:>10}'.format('aaa')) # 结果：右对齐的： aaa
print('居中对齐：{:^10}'.format('aaa')) # 结果：居中对齐： aaa
传统的格式化输出 %
列表
列表（list）用中括号来表示，其中的内容能够为任意类型。例如：['python','and',1,(1,'a')]
注意：空列表的布尔值为False，空列表就是列表中没有任何元素，空格都不行，示例：li = [ ]
字符串，列表和元组一样，属于序列类型，就是数据内部的元素是有顺序，有下标的，他们都能够通过下标取值，也能够进行切片操作
这里要介绍一下下表取值和切片的具体实现
下标取值
li = ['112','aa','java',78]
tu = ('python',98,'80%')
# 正向下标取值，索引从0开始
print(li[2]) # 结果：java
print(tu[1]) # 结果：98
# 反向下标取值，索引从-1开始
print(li[-3]) # 结果：aa
print(tu[-2]) # 结果：98
切片
切片用于获取数据中的某一段数据。
li = [11,22,33,44,55,66,77,88,99]
# 两个参数 [a:b]时，取索引为 [a,b) 的数值
print(li[:]) # 结果：[11, 22, 33, 44, 55, 66, 77, 88, 99]
print(li[2:]) # 结果：[33, 44, 55, 66, 77, 88, 99]
print(li[:5]) # 结果：[11, 22, 33, 44, 55]
print(li[2:5]) # 结果：[33, 44, 55]
# 三个参数 [a:b:c]时，取索引为[a,b),步长为c的数值
print(li[1::2]) # 结果：[22, 44, 66, 88]
# 也能够进行反向切片，最后一位从 -1 开始
print(li[-1:]) # 结果：[99], 含义是 从左到右读取索引从-1开始，到列表的最后一个 的数据
print(li[:-1]) # 结果：[11, 22, 33, 44, 55, 66, 77, 88]，含义是 从左到右读取索引从0开始，到索引为-1但不包含索引-1数值 的数据
print(li[-1:-5]) # 结果：[]， 含义是 从左到右读取索引从-1开始，到索引为-5但不包含索引-5数值 的数据
print(li[-1:-7:-2]) # 结果：[99, 77, 55]，含义是 从右到左读取索引从-1开始，到索引为-7但不包含索引-7数值，且每两个读取第一个 的数据
列表的常用方法
li = [11,22,33,44,55,66,77,88,99]
# 查看列表中有多少个元素
print(len(li)) # 结果：9
'''
列表的增删改查方法：
增加： append，extend，insert
删除： remove, pop ,clear
修改： 下标赋值
查找： 下表取值，index，count
'''
# append 向列表尾部添加一个元素
li.append('123')
print(li) # 结果：[11, 22, 33, 44, 55, 66, 77, 88, 99, '123']
# extend 向列表尾部添加多个元素
li.extend(('new','one','two'))
print(li) # 结果：[11, 22, 33, 44, 55, 66, 77, 88, 99, '123', 'new', 'one', 'two']
# insert 向列表中的指定位置添加一个元素
li.insert(2,'11')
print(li) # 结果：[11, 22, '11', 33, 44, 55, 66, 77, 88, 99, '123', 'new', 'one', 'two']
# remove(value) 删除列表中第一次出现的value，如果没有则返回一个ValueError错误
li.remove(22)
print(li) # 结果：[11, '11', 33, 44, 55, 66, 77, 88, 99, '123', 'new', 'one', 'two']
# pop Remove and return item at index (default last).
li.pop(5)
print(li) # 结果：[11, '11', 33, 44, 55, 77, 88, 99, '123', 'new', 'one', 'two']
li.pop()
print(li) # 结果：[11, '11', 33, 44, 55, 77, 88, 99, '123', 'new', 'one']
# clear 清空这个列表中的数据
#li.clear()
#print(li) # 结果：[]
# 可以直接通过下标获得或者修改对应下标的值
print('li[5] = ', li[5]) # 结果：li[5] = 77
li[5] = 66
print('更新后的li[5] = ', li[5]) # 结果：更新后的li[5] = 66
# index Return first index of value.
print(li.index(55)) # 结果：4
print(li.index(66,3,7)) # 在index in [3,7]中的列表元素中查找 66 的下标
# count Return number of occurrences of value.
print(li.count(88)) # 结果：1
# sort 对列表进行排序，列表中必须全是数值。用的比较少
li2 = [22,66,99,29,34,56,34,33]
li2.sort()
print(li2) # 结果： [22, 29, 33, 34, 34, 56, 66, 99]
# reverse 列表倒序
li.reverse()
print(li) # 结果： ['one', 'new', '123', 99, 88, 66, 55, 44, 33, '11', 11]
# copy 将该列表复制一个副本
li3 = li.copy()
print(li3) # 结果： ['one', 'new', '123', 99, 88, 66, 55, 44, 33, '11', 11]
运算符的补充
身份运算符
# 身份运算符 ：比较两个数据是否引用的是同一个对象（即id地址是否相同） is is not
li = [11,22,33]
li2 = [11,22,33]
print(id(li)) # 结果：2664787874248
print(id(li2)) # 结果：2664787987016
print(li is li2) # 结果： False ，虽然两个列表的内容相同，但是在内存中的引用并不相同，所以这两个并非同一个对象
print(li is not li2) # 结果： True
成员运算符
# 成员运算符： 前一个元素是否为后一个参数的成员 in not in
li = [22,44,67]
print(44 in li) # 结果： True
print(5 in li) # 结果： False
print(22 not in li) # 结果： False
元组（tuple）
具体元组的操作详见我的另外一个博客
集合（set）
通过{}来表示，其中只有数据，例：s = {22,66,99,200,34,52,52,66}
集合的特性：
- 集合是无序的
- 集合的数据不能够存在重复的元素
- 集合中的数据只能是不可变类型
集合的应用：
- 对数据进行去重
s = {22,66,99,200,34,52,52,66}
print(s) # 结果：{66, 99, 34, 200, 52, 22}
# 实际应用：对数据进行去重
li = [11,2,54,57,1,45,11,4,1,45,565,21,54,77,45]
res = set(li)
print(res)
new_li = list(res)
print(new_li)
因为集合中的数据只能够是不可变类型的数据，如果你不确定这个数据是不是一个可变类型的数据，将其放入集合就好啦。如果是可变类型的数据，将会报错。
可变类型：列表，字典，集合
不可变类型：字符串，数值，元组
函数的参数
函数如果返回多个值，那么返回的是一个元组。
参数分为实参和 形参：
实参：调用事件时小括号中的参数，用来传递给函数用的
形参：定义函数时小括号中的参数，用来接受参数用的
参数传递的三种形式：
- 位置参数：按照位置进行传递
- 关键字参数：通过关键字指定传给某个参数
- 序列传参（
调用函数时用*号将序列拆解开，再通过位置传参一一对应，用于元组和列表。也可通过**拆解字典，再通过位置传参一一对应）
同时使用位置参数和关键字传参的时候，位置参数在前面
参数定义的三种形式：
- 必备参数，即我们平时直接在小括号中写的参数，定义之后再调用函数时就必须要传递该参数。
- 默认参数（缺省参数）：调用参数时，默认参数的值如果没有传入，那么该参数的值就是默认值
- 不定长参数：有时可能一个函数需要处理比声明的参数更多的参数时，就需要使用不定长参数
不定长参数分为两种：第一种是*name，第二种是**name。加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。加了两个星号 ** 的参数会以字典的形式导入。
第一种形式的不定长参数，在传入额外的参数时可以不用指明参数名，直接传入参数值即可，第二种因为返回的是字典，所以传入时需要指定参数名。
- name形式：
def func(a,b,*args):
print(a)
print(b)
print(args) # 结果：(665, 32, 6, 2, 4, 5, 6)
func(1,4,665,32,6,2,4,5,6)
** name形式：
def func(a, b, **kwargs):
print(a)
print(b)
print(kwargs) # 结果：{'c': 665, 'dd': 32, 'ee': 6, 'j': 34}
func(1, 4, c=665, dd=32, ee=6, j=34)
常用的内置函数
min , max ,sum 函数
tu = (1, 3, 52, 5, 632, 0.5, 63, 5, 432,)
dic = {'one': 45, 'two': 354, 'three': 78}
# 获取最小值
print(min(tu)) # 结果:0.5
print(min(dic.values())) # 结果：45
# 获取最大值
print(max(tu)) # 结果:632
print(max(dic.values())) # 结果：354
# 求和
print(sum(tu)) # 结果:1193.5
print(sum(dic.values())) # 结果：477
filter 函数：
# filter(参数1，参数2) 参数1：函数（过滤的规则） 参数2：需要过滤的数据
# 将参数1函数作用于参数2中的数据，然后返回结果为True的数据
# 过滤元组中大于50的数据
def func(x):
return x>10
res3 =filter(func,tu)
print(list(res3))
匿名函数，详见我的另一个博客
enumerate函数：获取后面Iterator的索引和相对应的值组成一个枚举对象。
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons))) # 结果 ：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
print(list(enumerate(seasons, start=1))) # 结果 ：[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
dic= {'a':22,'n':7,'jh':88}
print(list(enumerate(dic))) # 结果：[(0, 'a'), (1, 'n'), (2, 'jh')]
print(list(enumerate(dic.values()))) # 结果： [(0, 22), (1, 7), (2, 88)]
eval函数：将字符串最外面的引号去掉，然后识别其中的有效表达式
s = '[1,44,5.2,4,2,4,3,5,2,32,342]'
print(type(eval(s))) # 结果：<class 'list'>
dic = "{'s':34,'ed':3454,'a':4354,'g':53}"
print(type(eval(dic))) # 结果：<class 'dict'>
str = "'hwjkehewkjb'"
print(type(eval(str))) # 结果：<class 'str'>
异常处理
使用关键之 try ,except,else,finally。
try:
# 将可能会出错的代码放在 try 中
a = 2
# ZeroDivisionError
print(a/0)
# NameError
#print(a1)
except ZeroDivisionError as ze:
# except 用来捕获对应的错误，捕获到之后就执行其中的代码块
# 将出错后的处理方式写在 except 中
print('代码发生错误,错误原因：{}'.format(ze))
except NameError as ne:
# 可以使用多个 except 语句来捕获不同的错误，并且处理方式不同
print('代码发生错误，错误原因：{}'.format(ne))
else:
# 如果代码没有出错，则执行以下代码
print('你的代码没有错误')
finally:
# 无论是否捕获到错误，都会执行 finally 中的代码块
print('程序结束')
最后总结一下：
如果你对此文有任何疑问，如果你也需要接口项目实战，如果你对软件测试、接口测试、自动化测试、面试经验交流感兴趣欢迎加入：软件测试技术群：593462778，群里的免费资料都是笔者十多年测试生涯的精华。还有同行大神一起交流技术哦。
作者：暗潮汹涌
原创不易，欢迎转载，但未经作者同意请保留此段声明，并在文章页面明显位置给出原文链接。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
