python

python输出方式

文本方式输出：建立以.py为尾缀的文本文档文件，用命令行模式，输入python hello.py，得到文本输出内容
pycharm输出

代码注释

单行注释：#

算数运算符
- 　　+ - * / // % **
- 优先级概念
- 字符串可以和数字相乘
```
print( 'word' * 3)
```
变量命名习惯：字母开头，不能有特殊符号，可以加下划线。
- 字母应该小写 first_name
- 小驼峰 firstName
- 大驼峰 FirstName

python数据类型

1.数字型

整数 int

浮点型 float

布尔值 bool true 真

false 假

2.非数字类型

列表

元组

集合

字典

3.None

首字母为大写的N

是空的

字符串的计算

字符串+字符串

　　两个字符串拼接在一起

字符串 * 数字
- 　　字符串的重读多少遍

不同数据类型之间的相互转化

1. 转化为字符串

str（被转化的内容）

2.转化为整数行

int（要转化的内容）浮点型转化成整型取其整数部分，如果想四舍五入，在后面加0.5

3.转化为浮点型

float（）整型转化为浮点型，后面加上小数位

字符串必须是数字才能转换成浮点型和整型

非数据类型

一. 列表

[] 是列表的标志
定义一个空列表 list1 = []
空列表 list1 = list()
python是从第零位开始的
a = [1,2,3,4] a[1] = 2 也叫索引
- 　　不能访问不存在的索引 a[5]
查看列表的所有方法
- ```
print ( dir (list 1))
```
　　增、删、改、查
- 　　增 insert
  - list1.insert(索引，数值)
  - append 在尾部插入数值
  - extend 将一个列表的信息导入到另一个列表的信息
- 删
  - 　　del/remove del(list[1])/list1.remove(数值)　　　
  - pop list1.pop（索引）删除尾部信息　remove后面删除的是数值，pop后面删除的是索引，两者后面接的都是括号
  - clear 清楚所有信息
- 改 list1[1] = 数值
- 查 dir(list1)
　　count list1.count('刘备') 统计数据出现的次数
index list1.index('刘备') 数据所在的索引
公共用法
- 　　len len(list)查找数组中的数值的数量
- max
- min
- in
- not in
　　排列顺序
- list1.sort（reverse = true）从大到小排序　　　　
- list1.reverse（）　　　倒着排序

　　for遍历列表

list1 = ['张三', '李四', '刘老二', '王麻子', '王达成', '隔壁老王']# 写代码判断列表中名字为三个字的人有几个
sum1 = 0
for n in list1:
    sum2 = 0
    for a in n:
        sum2 += 1
    if sum2 == 3:
            sum1 += 1
print(sum1)  #注意缩进的位置，代表着逻辑的关系

列表推导式
- 　　list1[] = [x for x in range(起始数值，终止数值，间隔) if 条件]
- 终止数值是空的，到不了
- 可以到这来，也可以是负数
  - 　list1[] = [x for x in range(30，-1，-1) if x%2 == 0]

　拆包

list1 = ['关羽' ,'张飞','赵云','刘备']
a,b,c,d = list1

二. 元组

格式
- 　　truple1 = 1，
- truple1 = 1，2，3
- truple = （1，）
- truple = （1，2，3）
　　索引
- 　　a = truple[1]

元组与列表的转化
- 　　元组转列表
  - 　　list(元组名)
- 　　列表转元组
  - 　　 truple（列表名）

三.集合

标志{}
空集合 set1 = set{}
与列表的区别
- 　　　集合没有顺序，列表是有顺序的
- 　　　集合里面的数据是唯一的，不可重负
用法　　　　
- 　　 set1.add（）
- set1.remove（）
- set1.clear()
- set1.pop() 随机删除一个

四.字典

定义：dict1 = {‘key’：‘value’}
空集合 dict1 = {}
dict1【key】= value ：可以用来增加或者修改内容
a = dict[key] : 得到对应的值
pop【key】删除key键，以及对应的value值
遍历
- 　　for a,b in dict{}.items:

五.字符串

定义：str1 = ‘’
str[索引] 查找指定内容，但是不能修改内容
- 　　第一个索引是零，最后一个索引是-1
判断
- 判断是否是数字 isdigit
  - 　　用法：if str1.isdigit():
- 判断是否是字母 isalphat
- 判断是否大小写 isupper/islower
find 查找子串位置 str1.find（‘hello’）
replace 代替
- 　　用法：str1.replace（‘word’，‘hello’）
split 字符串分解
- 拆分的值放到一个列表中
- 用法：list1 = str1.split('拆分的值')
count 统计出现的字符串的次数
- 　　print（str.count('s')）
格式化
- 　　%x 十进制转化成十六进制
- %d 整型 %06d 代表六位数，不够前面补0
- %f 浮点型 %.6f 代表小数点后面六位
- %s 字符串
- 用法： print（‘请输入一个整数%06d’ % s）
切片
- 　　用法 str1 = str2[2:5:-1]
- 初始步长为0的时候，从头开始
- 终止步长为零的时候，直接到结尾
- 步距默认为1
　　索引

　　列表的索引可以改变值
字典的键可以改变值

字符串的索引可以改变值

list1 = ['a','b','E','s','a','u']
x = list1[1]
print(x)
list1[2] = '刘备'
print(list1[2])
str1 = str(list1)
str2 = str1.replace("', '","")
print(str2)

input返回值永远是字符串类型

函数

定义和调用方法
- 　　　　def 函数名（）：

函数代码

调用函数函数名（）

函数参数
- 　　内部是内部的变量，外部是外部的变量，不能相互改变，互不干扰。
- 参数的输入
  - 　　可以直接在封装函数名的括号内直接添加变量
  - 在函数内部设置自定义变量
　　　形参与实参　　　　
- 　　形参：定义函数时，括号里面的参量，只能是变量
- 　　实参：调用函数时，括号内的参量，实参可以是常量，变量，或者表达式　　
　　函数的返回值：return
- 　　函数内容通过return，给调用者一个值
- return返回的可以是常量，变量，表达式
- 与调用函数的print相互配合使用
　　函数的嵌套

局部变量：在程序运行中，调用该函数时，局部变量在内存中出现。函数结束或未调用函数，局部变量都会在内存中消失

全局变量：程序运行开始，在内存中出现，程序运行结束，在内存中消失。（参考运行内存，一个概念）

函数内部的变量与外部变量名字相同时，使用内部的变量
global关键字
- 　　当在函数内部需要修改全局变量是，可在变量名前加上global，即可实现修改
当局部变量中，参数的形式是列表时，不用声明，直接在内部即可对外部的列表参数进行修改。
lambda
- 　　用于小型函数
- 用法：x = lambda a,b : a + b
- x = (lambda a if a > b else b)(1,2)

面向对象基础

　　类：包含属性和方法
　　对象：先有类后有对象，对象具有属性
实例：通过类创建的对象，叫做类的实例
实例化：创建对象的动作叫做实例
基础语法
- 　　class 类名：属性，方法
　　对象名 = 类名（参数列表） #创建对象

　　对象名.方法（参数） #调用方法

　　对象名.属性 = 参数 #修改属性参数的值　
self
- 　　是指针指向类这个整体
- 方法的本质是函数，但是函数之间的变量是不能相互通用的，通过在参数前插入self，实现在同一个类中，参数可以随意使用
- 作用：
  - - 在方法内部定义和使用属性
    - 实现方法间的嵌套，在方法名前加上self
　　__init__　　
- 　　在输出属性时，，这时会调用init函数，会在内存中建立对象
- 就是建立属性的，在调用函数时，不用直接输出方法名字，c.cat('黑'，‘12’)
- init中的形参最好有缺省值
　　__del__
- 　　当调用的函数程序结束时，对象在内存中销毁，会自动调用del函数
- del函数只有一个参数self
　　__str__
- 　　只有一个参数self
- 必须有return返回值，且必须返回一个字符串
- 当把一个带有str方法的对象放到print里面,print函数会显示str方法return返回的字符串
- 如果类没有str方法,那么类实例化的对象放到print里面显示的是对象的内存地址

面向对象的特性

一.封装

封装在类内的属性和方法，在类外无法使用，只能在类内进行修改
使用方法
- 在属性或方法的名称前面加上两个下划线 "__"
在不同的方法中调用私有属性和私有方法也要加上两个下划线　 "__"

二.继承

在定义类的时候，其实每个类名称的后面都有（），如果括号里面没有内容，则默认可以省略
每个类都有其父类，如果父类没有内容，则默认其父类为object
子类名称后面的括号中是哪个类的名字，则该类即为这个子类的父类，子类继承父类的所有属性和方法，直接调用就可以　　
父类的私有属性和方法不能继承给子类
多级继承
- 　　原理就是和继承一样，在括号中加入父类的名字，可以循环嵌套加
方法重写　　　
- 　　父类方法内容不能满足子类使用
- 覆盖：在子类中直接定义一个新的方法，名字与父类相同，即可将其覆盖
- 增加：在调用的方法名称前加入super（）.

三.多态

不同的子类调用调用相同的父类所产生的结果也可能不一样
多态的前提,不同的子类来自相同的一个父类,子类会覆盖父类的方法

四.类属性和类方法

类属性
- 　　在类里面方法外面定义的属性
- 不用加self
- 在类外面调用的时候，不用实例化，直接类名.属性调用
- 在类的普通方法里面调用时，参考全局变量的调用，直接类名.属性名称调用
类方法
- 　　在定义方法前，先用@classmethod　声明变量
- 　　在类方法中的参数是cls
- 在类方法中调用类属性格式 cls.类属性名。
- 类方法中不能调用普通方法和普通属性，因为类方法没有实例化。

五.静态方法

在定义方法前用@staticmethod 声明静态变量
是一个独立的与类存在的函数，不能调用类里面的任何方法和函数
不用实例化，可以直接调用类名.方法名
目的：避免函数过多，发生错乱。

文件操作

file = open('D:\1.txt','r')#文件名+读写方式，文件名尾缀要加属性
txt = file.read()                 #读对应读
print(txt)
file.close()

w对应的写,直接替换文件里面的内容，a对应的是添加，补充文件的内容，rb代表只读二进制，wb,ab代表只写二进制
如果文件格式是utf8的文件，需要指定字符集

file = open('文件名'，‘r’，encoding =‘ utf8’)

readline（）读取每一行文件
- 　例：　　　读取偶数行文件

file = open('D:\1.txt','r',encoding = 'utf8')
index = 1
while True:
    txt = file.readline()
    if txt = ''
        break
    if index % 2 == 0
        print(txt)
    index += 1
file.close()

with open 写法
```
with open ('D:\1.txt','r') as file:
```
json文件

unittet

一.Testcase

导入模块　　
定义一个类
- 　　这个类必须继承unittest.TestCase

设计测试用例，类中的方法代表一个测试用例

import unittest


class my_testz(unittest.TestCase):
    
    def test_001(self):
        print('001')

    def test_002(self):
         print('002')

　　方法名必须为以test开头的，符合命名规则的名称

二.TestSuite

把多个测试用例整合成一个测试套件
导入模块
导入测试用例所在的py文件
测试用例实例化

调用对象的addtest方法

import unittest
import Testcase_01

suite = unittest.TestSuit()
suite.addTest(测试模块.类（方法）)
suite.addTest(测试模块.类（方法）)

#makeSuite代表添加这个类的整个方法
suite.addTest(unittest.makeSuite(模块.类))

三.TextTestRunner

执行测试用例，本质上是unit test库中的一个类
操作步骤
- 　　1,本质上是类，所以第一步将对象实例化
- 　　2.调用类中的run方法，执行测试套件　　
```
runner = unittest.TextTestRunner()
runner.run(suite)
```
这个函数只能运行测试套件

四.TextLoader　　

可以指定目录查找py文件中的所有测试用例，添加到测试组件中去

测试步骤

　　1.unittest库中的一个类，将对象实例化

　　2.调用类中的discover方法

suite = unittest.TextLoader().discover('py文件所属文件夹名','py文件名')　#不知道为什么，将这段程序，分成两部分不行。第一将对象实例化，第二调用类中的discover方法

五.Fixture

可以在测试用例执行前自动调用方法，可以在测试用例执行后自动调用方法
分为三个等级：方法级，类级，模块级

操作步骤

#方法级别:测试用例执行多少次，自动调用多少次
import unittest

def my_sum(a,b)
   return a + b
class my_test(unittest.TestCase):#必须得继承unittest.TestCase这个类
   def setup(self):
         print('steup自动启用了')
    def tearDown(self):
        print('tearDown自动启用了')
    def test_01(self):
        print(my_sum(5,6))

#类级别：类开始时自动执行，类结束时自动执行
import unittest

def my_sum(a,b)
   return a + b
class my_test(unittest.TestCase):#必须得继承unittest.TestCase这个类
    @classmethod
   def setup(self):
         print('steup自动启用了')
    @classmethod
    def tearDown(self):
        print('tearDown自动启用了')
    def test_01(self):
        print(my_sum(5,6))

#模块级别：在py文件开始时自动调用，在py文件结束时自动调用
import unittest

def setupModule():
    print('steup自动启用了')
def tearDownModule():
    print('tearDown自动启用了')
      
      
def my_sum(a,b)
   return a + b

class my_test(unittest.TestCase):#必须得继承unittest.TestCase这个类
   
    def test_01(self):
        print(my_sum(5,6))

异常

捕捉异常

try:
    a = int(input("请输入a的值"))
    b = int(input("请输入b的值"))
    print(a / b)
except ValueError:
    print("请输入正确的整数")
except ZeroDivisionError:
    print("除数不能为0")
except Exception as result:
    print("未知异常", result)
else:
    print("代码没有异常发生")
finally:
    print("代码执行完成")#无论是否发生异常，最后都要执行这个语句

主动抛出异常

def my_name(str1):
    for n in str1:
        if n >= '0' and n <= '9':
            return True
        return False

try:
    name = input('请输入姓名')
    if my_name(name):
        raise Exception('姓名输入错误')
    age = int(input('请输入年龄'))
    if age<0:
        raise Exception('年龄输入错误')
except Exception as result:
    print(result)

模块
- 　　一个模块就是一个py文件
- 　　也要符合变量命名规则，一般是用小写字母开头
- 　　form 模块 import 方法名
  - 　　调用后，使用该方法时，前面不用添加模块名
- 　　__name__属性：每个py文件都有自己的属性
  - 　　print（__name__）如果这个py文件是正在执行的，则会显示__main__,如果这个py文件是被调用的，则会显示这个py文件的模块名　　
包
- 　　包是一个特殊的目录
- 里面必须得有 __init__.py 文件
  - 　　
```
from . import 模块1
from. import 模块2
```
- 当需要同时调用很多文件时，可以使用包文件　
- init文件中导入的模块才能在调用包中使用　　
- 包的调用
  - 　　import 包名
  - from 包名.模块名 import 函数名如何有类的话怎么导入

posted @ 2022-02-06 20:04 麻皮虫阅读(71) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Python基础知识

· python语法简单总结

· python语法

· python基础(未完)

· 【二】python学习总结

公告

昵称：麻皮虫
园龄： 3年2个月
粉丝： 0
关注： 4

+加关注

2025年3月

日

一

二

三

四

五

六

软件测试小白博客园记录自己成长