【Python】基础知识整理

谁践踏了优雅 2023-07-06 11:42 17阅读 0赞

本篇博客是对python中一些基础语法，编程知识的整理。因为是在自己的认知基础上所写，写得比较简略。部分知识也并未深入探讨学习，看看就好

### 文章目录 ###

*   *   *  变量的命名规则
         *  随机数
         *  字符串
         *   *  字符串的拼接：
             *  字符串常用方法
             *  字符串转义
         *  类型转换
         *   *  print不换行输出
         *  格式化输出的几种方式
         *   *  format 格式化输出：
             *  传统的格式化输出 %
         *  列表
         *   *  下标取值
             *  切片
             *  列表的常用方法
         *  运算符的补充
         *   *  身份运算符
             *  成员运算符
         *  元组（tuple）
         *  集合（set）
         *  函数的参数
         *  常用的内置函数
         *  异常处理

### 变量的命名规则 ###

应满足以下条件：

1.  由数字、字母、下划线组成，但是不能以数字开头
2.  不能使用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']

1.  变量命名尽量做到见名知意

变量的命名风格：请使用下划线命名风格，例如：`regist_page, python_grammer`

### 随机数 ###

在python中有一个内置的随机数模块random，可以用来生成随机数，常用两个方法：

1.  random.random() 用来生成一个 \[0, 1) 的随机数
2.  random.randint(a, b) 用来生成一个 \[a, b\] 的随机数
3.  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类型，通常用单引号、双引号、或者三引号包起来。  
单引号和双引号没有任何区别，都是表示一行字符串  
三引号（三个单引号和双引号是一样的）可用来表示多行字符串

空字符串：只有引号，引号中没有任何内容（连空格键都没有）

#### 字符串的拼接： ####

1.  使用加号进行拼接：`s1 = 'a' s2 = 'b' s3 = s1 + s2` 结果是 `a b`
2.  使用 join 进行拼接：`s4 = ' and '.join((s1,s2))`,结果是 `a and b`

#### 字符串常用方法 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NjU5Nzc3_size_16_color_FFFFFF_t_70]  
其中某些方法的应用见下方代码：

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 格式化输出： ####

该函数能够将字符串当成一个模板，通过传入的参数进行格式化，并且使用大括号 \{\} 作为特殊字符胎体 ‘%’  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NjU5Nzc3_size_16_color_FFFFFF_t_70 1]  
其中上面的左对齐右对齐和居中对齐代码如下，还能在<,>,^前加上字符，表示用该字符填充其他的部分。

print('默认的：{:10}'.format('aaa'))                   # 结果：  默认的：aaa
    print('左对齐的：{:<10}'.format('aaa'))                # 结果：左对齐的：aaa
    print('右对齐的：{:>10}'.format('aaa'))                # 结果：右对齐的：       aaa
    print('居中对齐：{:^10}'.format('aaa'))                # 结果：居中对齐：   aaa

#### 传统的格式化输出 % ####

![在这里插入图片描述][20200219230206931.png]

### 列表 ###

列表（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） ###

具体元组的操作详见我的另外一个[博客][Link 1]

### 集合（set） ###

通过\{\}来表示，其中只有数据，例：`s = {22,66,99,200,34,52,52,66}`  
集合的特性：

1.  集合是无序的
2.  集合的数据不能够存在重复的元素
3.  集合中的数据只能是不可变类型

集合的应用：

1.  对数据进行去重

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)

因为集合中的数据只能够是不可变类型的数据，如果你不确定这个数据是不是一个可变类型的数据，将其放入集合就好啦。如果是可变类型的数据，将会报错。

可变类型：列表，字典，集合  
不可变类型：字符串，数值，元组

### 函数的参数 ###

函数如果返回多个值，那么返回的是一个元组。

参数分为实参和 形参：  
实参：调用事件时小括号中的参数，用来传递给函数用的  
形参：定义函数时小括号中的参数，用来接受参数用的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NjU5Nzc3_size_16_color_FFFFFF_t_70 2]  
**参数传递的三种形式：**

*  位置参数：按照位置进行传递
 *  关键字参数：通过关键字指定传给某个参数
 *  序列传参（`调用函数时用*号将序列拆解开，再通过位置传参一一对应，用于元组和列表。也可通过**拆解字典，再通过位置传参一一对应`）

同时使用位置参数和关键字传参的时候，位置参数在前面

**参数定义的三种形式：**

1.  必备参数，即我们平时直接在小括号中写的参数，定义之后再调用函数时就必须要传递该参数。  
    ![在这里插入图片描述][20200222220614644.png]
2.  默认参数（缺省参数）：调用参数时，默认参数的值如果没有传入，那么该参数的值就是默认值  
    ![在这里插入图片描述][20200222220709946.png]
3.  不定长参数：有时可能一个函数需要处理比声明的参数更多的参数时，就需要使用不定长参数  
    不定长参数分为两种：第一种是\*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))

匿名函数，详见我的另一个[博客][Link 2]

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**，群里的免费资料都是笔者十多年测试生涯的精华。还有同行大神一起交流技术哦。

作者：暗潮汹涌  
原创不易，欢迎转载，但未经作者同意请保留此段声明，并在文章页面明显位置给出原文链接。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NjU5Nzc3_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200219230944633.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NjU5Nzc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NjU5Nzc3_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200219230105358.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NjU5Nzc3,size_16,color_FFFFFF,t_70
[20200219230206931.png]: https://img-blog.csdnimg.cn/20200219230206931.png
[Link 1]: https://blog.csdn.net/qq_34659777/article/details/104307137
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NjU5Nzc3_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200222191701105.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NjU5Nzc3,size_16,color_FFFFFF,t_70
[20200222220614644.png]: https://img-blog.csdnimg.cn/20200222220614644.png
[20200222220709946.png]: https://img-blog.csdnimg.cn/20200222220709946.png
[Link 2]: https://blog.csdn.net/qq_34659777/article/details/104339292