【python自动化测试】1- python基础和pycharm使用
python基础和pycharm使用
1.pycharm
File--Settings--Editor--File and Code Templates--Python Script:
"""
===============
author:${USER}
time:${DATE}
E-mail:1399892035@qq.com
===============
"""
${PROJECT_NAME} - 当前Project名称;
${NAME} - 在创建文件的对话框中指定的文件名;
${USER} - 当前用户名;
${DATE} - 当前系统日期;
${TIME} - 当前系统时间;
${YEAR} - 年;
${MONTH} - 月;
${DAY} - 日;
${HOUR} - 小时;
${MINUTE} - 分钟；
${PRODUCT_NAME} - 创建文件的IDE名称;
${MONTH_NAME_SHORT} - 英文月份缩写, 如: Jan, Feb, etc;
${MONTH_NAME_FULL} - 英文月份全称, 如: January, February, etc；Package会多了一个__init__.py文件，说明该目录下的py文件可以当做模块被其他py文件导入
使用模块的好处：避免函数名和变量名冲突；实现代码复用；
使用包的好处：避免模块名冲突，实现代码复用；
__init__.py文件的用处：
（1）用于标志一个文件夹是一个python包
（2）通过定义__all__ 变量定义模糊导入时from package import *要导入的内容,_
注意__all__只能定义通过import * 的方式导入的变量，对from package.module import obj 不起作用!
# 在pakcage1里面有module1(func1, func2), module2, module3模块，在package2要导入
from package1 import module1, module2, module3
# 有时偷懒会写成,虽然pep8不推荐，这种方式会导入所有非下划线开头的方法和变量
from package1 import *
# 如果有些非下划线开头的方法和变量也不想被导入，可以在模块里面和包的__init__.py文件定义__all__，把允许import的对象暴露出来。譬如不允许导入module1的func1,和module3
# module1.py里面加上
__all__ = ['func1', 'func2']
# package1的__init__.py文件,这样就无法通过from package1 import *的方式导入module3，但仍可通过from package1 import module3导入
__all__ = ['module1','module2']（3）简化导入一个包里面的模块的类的导入语句
# 在package2里面的moudle2中需要导入package1包下的模块包module_package1下的一个模块module1的一个类class1
from package1.module_package1.module1 import class1
# 如果我们在module_package1的__init__.py文件里写了
from module1 import class1
# 那在在package2的module2导入class1就可以写为(少写一个模块名)
from package1.module_package1 import class1在pycharm里关闭项目，然后去项目所在磁盘位置，删除项目文件
https://blog.csdn.net/weixin_37292229/article/details/81737194
运行py文件：ctrl + shift + F10
调试模式: shift + F9
自动调整为pip8规范：ctrl + shift + alt + l
注释：ctrl + /
展开代码：ctrl + shift + +
收缩代码：ctrl + shift + -
批量缩进(或名"对齐")
缩进：Tab
反向缩进：Shift+Tabpycharm为python3提供了虚拟环境，每个虚拟环境里面的第三方库是隔离的，为支持多版本python在同一个机器上开发或运行时的版本兼容。deactivate 退出venv的终端
修改源为国内镜像地址，加速下载
一次性指定源： -i https://pypi.tuna.tsinghua.edu.cn/simple
永久修改：
linux下，修改 ~/.pip/pip.conf (没有就创建一个)， 修改 index-url 为国内镜像地址，内容如下：
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
windows下，直接在user目录中创建一个pip目录，如：C:\Users\xx\pip，新建文件pip.ini，内容如下
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
pip install lib_name
# 其他命令
list
download
uninstall
show
check
search2.python 基础
命名规范：以字母或下划线开头，由字母，下划线或数字组成.尽量以字母开头，不能是python的关键字，注意下划线开头是有特殊意义的，谨慎使用。
# 查询python关键字
from keyword import kwlist
print(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']命名方式：
- 蛇形：student_name
- 大驼峰：StudentName
- 小驼峰 : studentName
变量名、方法名、模块一般用小写，蛇形，常量用全大写；类名用大驼峰
下划线开头都是有特殊意义的，一般不用，要结合场景
单引号跟双引号没有区别：当字符串中含有单引/双引，则外层可以用双引/单引括起
三引号2个用处：
（1）保持文本格式，如换行，如字符串即有单引又有双引
（2）表示注释
双引号内换行拼接：加“\”后换行，打印出来不会换行，代码不会太长
反斜杠用法
- 用于把后面的字符串转成特殊意义，如n前面加\ ,即\n，表示换行符
- 把特殊字符转成普通字符串，如\n前面加,即\\n 表示n。
- r+字符串，表示不转义，注意r原生字符从不能以奇数个\结尾，否则会报错
type(str1) 返回数据类型
isinstance(a, type) 判断a是不是type类型的数据
可变/不可变类型
原文地址：http://www.cnblogs.com/huamingao/p/5809936.html
可变类型 Vs不可变类型
可变类型（mutable）：列表，字典
不可变类型（unmutable）：数字，字符串，元组
这里的可变不可变，是指内存中的那块内容（value）是否可以被改变
一句话判断最小数：x if x<y and x<z else y if y<z else z
2.3.1 数值
1. 类型
- 整型 int
小整数池：-5~256，该范围内的变量预先创建好的变量。(在pycharm里面看不到下面的效果，因为pycharm做了更大的整数池)。
通过id查看内存地址是否执行同一个地址。== 用于判断值是否相等，is判断是否同一内存地址
>>> a=100
>>> b=100
>>> id(a)
140708647059376
>>> id(b)
140708647059376
>>> a==b
True
>>> a is b
True
>>> c=1000
>>> d=1000
>>> id(c)
2349952671472
>>> id(d)
2349952671280
>>> c == d
True
>>> c is d
False浮点型 float
关于精度
1.可以使用round(float_num, num) 确定精度
2.用math的ceil和floor方法上下取整
3.用更高精度的模块decimal
4.用format格式化输出时指定精度
In [3]: a=21.2345 In [4]: round(a,2) Out[4]: 21.23 2、%nf In [5]: b = '%.2f'%a In [6]: b Out[6]: '21.23' In [7]: b = float('%.2f'%a) 3、'{.%2f}'.format() In [10]: b = '{:.2f}'.format(a) In [11]: b Out[11]: '21.23'布尔类型 bool
True：长度不为空的字符的布尔值都是True，注意首字母大写
False：None, 0, '', ' ', [],{},()
复数complex
2. 运算符
算术运算符：+ - * / // % **
赋值运算符：= += -= *= /=
比较运算符：> < >= <= == !=
逻辑运算符：and or not
成员运算符：in , not in （数值类型不支持）
身份运算符：is , not is （判断2个标识符是否引用同一个对象,是否指向同一块内存）
优先级：算术可用()括起表示优先计算
a/b 完整结果
a//b 结果取整
a%b 结果取余3. random模块
randint(a, b) 返回a~b之间的随机整数，包含a和b
random() 返回0-1之间的随机小数，不包含1
uniform(a, b) 返回a~b之间的随机小数，底层通过random()实现
choice(seq) 返回seq可迭代对象里面的元素
2.3.2 字符串
1. 索引与切片
索引： 字符串支持下标索引，从左到右是从0开始，从右往左是从-1开始
切片： 取头不取尾，左闭右开，支持设置步长
拼接：字符串可以用+拼接，用*表示倍数
>>> str1='abcdefg'
>>> str1[0]
'a'
>>> str1[2]
'c'
>>> str1[-1]
'g'
>>> str1[1:]
'bcdefg'
>>> str1[1:3]
'bc'
>>> str1[1:7:3]
'be'
>>> str1[::-1]
'gfedcba'
>>> str2='123'
>>> str1+str2
'abcdefg123'
>>> str1*2
'abcdefgabcdefg'2. 常用方法
注意，字符串是不可变数据类型，所有操作都不会修改原字符串
‘-’.join(str) 在iterable中间插入短横线，返回替换后的字符串
str.find(sub) 返回sub的下标，如不存在，返回-1
str.index(sub) 返回sub的下标，如不存在，抛出异常
str.split('sub'[,count]) 对str根据sub进行切割，默认是根据空格，换行符，制表符进行切割
str.strip() 去除头尾的空白字符
str.replace(old, new[,count]) 替换字符
>>> str1='abcdefg'
>>> str1[0]
'a'
>>> str1[2]
'c'
>>> str1[-1]
'g'
>>> str1[1:]
'bcdefg'
>>> str1[1:3]
'bc'
>>> str1[1:7:3]
'be'
>>> str1[::-1]
'gfedcba'
>>> str2='123'
>>> str1+str2
'abcdefg123'
>>> str1*2
'abcdefgabcdefg'
>>> '-'.join(str1)
'a-b-c-d-e-f-g'
>>> str1
'abcdefg'
>>> str3='11 A2\t3A3\n4A4'
>>> str3.split()
['11', 'A2', '3A3', '4A4']
>>> str3
'11 A2\t3A3\n4A4'
>>> str3.split('A')
['11 ', '2\t3', '3\n4', '4']3. 格式化输出
format 强大的格式化输出，用{}占位，%的占位濒临淘汰
占位
>>> str = '{}是一个{}岁的姑娘'.format('Ana',18) # 用花括号占位，按顺序 >>> str 'Ana是一个18岁的姑娘' >>> str = '今天是{2}年{1}月{0}日'.format(30,5,2019) # 花括号里面用数字可以指定顺序替换 >>> str '今天是2019年5月30日' >>> str = '{city}今天温度{temperature}度'.format(city='北京',temperature=34) # 指定key >>> str '北京今天温度34度' >>> str = '{0[1]}里面我最喜欢吃{1[3]}'.format(['零食','水果'],['薯片','橙子','牛肉干','葡萄']) >>> str '水果里面我最喜欢吃葡萄'补齐
>>> str = '{:a>10d}'.format(12345) # 右对齐，不够10位用a补齐 >>> str 'aaaaa12345' >>> str = '{:b<10d}'.format(12345) # 左对齐，不够10位用b填补 >>> str '12345bbbbb' >>> str = '{:^10}'.format(12345) # 居中，长度为10 >>> str ' 12345 '格式化数字
>>> str = '{:.2f}'.format(12312.123123) # 保留小数点后2位 >>> str '12312.12' >>> str = '{:.2%}'.format(12312.123123) # 转化成百分号并保留2位小数 >>> str '1231212.31%'
2.3.3 列表
可变数据类型，元素也可以是可变的其他数据类型
1. 索引与切片
同字符串
>>> li = [1, 2, 3, 4]
>>> li[1]
2
>>> li[2:4]
[3, 4]
>>> li[-1]
4
>>> li[::-1]
[4, 3, 2, 1]2. 常用方法
# 查找
>>> li
['b', 1, 4, 'b', 3, 10, (0, 1, 2), ['hello', 'world'], {'key1': 'value1', 'key2': 'value2'}, {1, 2, 3, 4, 5}, 'c', 0, 0]
>>> li.index('b')
0
>>> li.count('b')
2
# 增加
>>> li.insert(2, 'haha') # 在指定位置插入一个元素
>>> li
['b', 1, 'haha', 4, 'b', 3, 10, (0, 1, 2), ['hello', 'world'], {'key1': 'value1', 'key2': 'value2'}, {1, 2, 3, 4, 5}, 'c', 0, 0]
>>> li.append('last') # 追加到尾部
>>> li
['b', 1, 'haha', 4, 'b', 3, 10, (0, 1, 2), ['hello', 'world'], {'key1': 'value1', 'key2': 'value2'}, {1, 2, 3, 4, 5}, 'c', 0, 0, 'last']
>>> li.extend([1,2]) # 在尾部追加另一个列表的元素
>>> li
['b', 1, 'haha', 4, 'b', 3, 10, (0, 1, 2), ['hello', 'world'], {'key1': 'value1', 'key2': 'value2'}, {1, 2, 3, 4, 5}, 'c', 0, 0, 'last', 1, 2]
# 删除
>>> li.pop() # pop默认移除最后一个元素
2
>>> li
['b', 1, 'haha', 4, 'b', 3, 10, (0, 1, 2), ['hello', 'world'], {'key1': 'value1', 'key2': 'value2'}, {1, 2, 3, 4, 5}, 'c', 0, 0, 'last', 1]
>>> li.pop(3) # pop可指定下标移除元素
4
>>> li
['b', 1, 'haha', 'b', 3, 10, (0, 1, 2), ['hello', 'world'], {'key1': 'value1', 'key2': 'value2'}, {1, 2, 3, 4, 5}, 'c', 0, 0, 'last', 1]
>>> li.remove('b') # remove移除指定元素
>>> li
[1, 'haha', 'b', 3, 10, (0, 1, 2), ['hello', 'world'], {'key1': 'value1', 'key2': 'value2'}, {1, 2, 3, 4, 5}, 'c', 0, 0, 'last', 1]
>>> li.clear() # 清空列表的元素
>>> li
[]
>>> del li # 删除对象引用
>>> li
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'li' is not defined
# 其他
>>> li1 = li.copy() # 复制列表的元素，会另外开辟一个内存空间
>>> li2 = li # 直接复制，使用同一个内存空间
>>> id(li1)
3020011212488
>>> id(li)
3020011212424
>>> id(li1)
3020011212488
>>> id(li2)
3020011212424
>>> li3 =[1,2,'a','b']
>>> li3.sort() # 排序，不支持不同类型数据的排序
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'
>>> li3=['a','d','b']
>>> li3.sort() # 默认是升序
>>> li3
['a', 'b', 'd']
>>> li3.sort(reverse=True) # 可指定降序
>>> li3
['d', 'b', 'a']2.3.4 元组
不可变序列
1.索引与切片
同字符串，列表操作
2.常用方法
>>> tup1 = (1,2,3,'a')
>>> tup1
(1, 2, 3, 'a')
>>> tup1.index(2)
1
>>> tup1.count(3)
12.3.5 字典
可变序列，python3.7后字典在底层存储是有序的,键值对形式，键唯一且不可变
1.支持键索引
>>> food = {'fruit':'apple', 'vegetable':'carrot','meat':'meat'}
>>> food['fruit']
'apple'
>>> food.get('fruit')
'apple'
>>> food['haha']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'haha'
>>> food.get('haha')2.相关方法
>>> food = {'fruit':'apple', 'vegetable':'carrot','meat':'meat'}
# 增加
>>> food.update({'snacks':'chips'}) # 插入一个字典
>>> food
{'fruit': 'apple', 'vegetable': 'carrot', 'meat': 'meat', 'snacks': 'chips'}
# 修改
>>> food.setdefault('drinks','juice') # 设置key默认值，不存在值插入该key
'juice'
>>> food
{'fruit': 'apple', 'vegetable': 'carrot', 'meat': 'meat', 'snacks': 'chips', 'drinks': 'juice'}
# 查询
>>> food.get('fruit') # 获取某个key的值，如不存在返回空，不会抛出异常
'apple'
>>> food.keys() # 返回所有key
dict_keys(['fruit', 'vegetable', 'meat', 'snacks', 'drinks'])
>>> food.values() # 返回所有值
dict_values(['apple', 'carrot', 'meat', 'chips', 'juice'])
>>> food.items() # 返回键值组成的元组列表
dict_items([('fruit', 'apple'), ('vegetable', 'carrot'), ('meat', 'meat'), ('snacks', 'chips'), ('drinks', 'juice')])
>>> food1 = food.copy() # 拷贝字典的所有元素
>>> food1
{'fruit': 'apple', 'vegetable': 'carrot', 'meat': 'meat', 'snacks': 'chips', 'drinks': 'juice'}
# 删除
>>> food.pop() # pop必须指定key
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: pop expected at least 1 arguments, got 0
>>> food.pop('meat') # 移除指定key
'meat'
>>> food
{'fruit': 'apple', 'vegetable': 'carrot', 'snacks': 'chips', 'drinks': 'juice'}
>>> food.popitem() # 移除最后一个元素，python3.7支持
('drinks', 'juice')
>>> food
{'fruit': 'apple', 'vegetable': 'carrot', 'snacks': 'chips'}
>>> food.clear() # 清除所有元素
>>> food
{}
>>> del food # 删除对象
>>> food
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'food' is not defined2.3.6 集合
可变类型，无序，元素唯一，一般用于去除重复元素
常用方法
>>> set1 = {1,2,'a',2,3,'b','a'} # 用花括号括起
>>> set1
{1, 2, 3, 'a', 'b'}
# 添加
>>> set1.add(4) # 添加单个元素
>>> set1
{1, 2, 3, 4, 'a', 'b'}
>>> set1.add(1)
>>> set1
{1, 2, 3, 4, 'a', 'b'}
>>> set1.update({1,2,3}) # 把另一个集合的元素加到本集合
>>> set1
{1, 2, 3, 4, 'a', 'b'}
# 删除
>>> set1.pop() # 随机删除一个元素
1
>>> set1
{2, 3, 4, 'a', 'b'}
>>> set1.remove(3) # 删除某个额元素
>>> set1
{2, 4, 'a', 'b'}
>>> set1.remove(333) # remove不存在的元素会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 333
>>> set1.discard(333) # discard删除不存在的元素不会报错
>>> set1.clear() # 清空元素
>>> set1
set()
>>> del set1 # 删除对象
>>> set1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'set1' is not defined3.关于编码格式
https://zhuanlan.zhihu.com/p/67865867
https://zhuanlan.zhihu.com/p/25148581
python2默认是ASCII编码，因为python2比unicode出现得早，所以默认是ASCII编码，不支持中文，需要加上在文件头加上coding=utf8才能处理中文。
python3默认使用utf8编码。
字节
计算机存储单元，一个字节byte等于8个比特
字符
信息单元，英文字符、数字、中文都是成为一个字符
字符集
包含字符的集合成为字符集，如ASCII字符集只包含了127个字符，包括数字，字母和一些符号，不包含中文；GB2312包含7000多个中文，GBK包含2万多个中文
字符码
字符集里面的字符的序号。如ASCII字符集里面字母a的序号是97
字符编码
字符集里的字符到字节流的映射，如ASCII字符集里面的字母a的序号是97，字节流编码即转成二进制，单字节表示是0X51，写入存储设备时是b'01100001'
编码和解码
把字符转换成字节流就是编码过程，把字节流转成字符就是解码过程。不同的编码方式，把不同字符当不同字节处理，如ASCII都是单字节，utf8是可变长字节，unicode2是双字节，unicode4是4个字节。
ASCII编码
较早出现的编码格式，一个字节（8个比特）表示一个字符（没有中文），总共127个字符，小于2的7次方，用7个二进制表示，称为基础ASCII，第8个二进制用于扩展。但由于各国的扩展不统一导致传输很混乱。
ASCII表
0～31及127(共33个)是控制字符或通信专用字符（其余为可显示字符），如控制符：LF（换行）、CR（回车）、FF（换页）、DEL（删除）、BS（退格)、BEL（振铃）等。通信专用字符：SOH（文头）、EOT（文尾）、ACK（确认）等；
ASCII值为 8、9、10 和 13 分别转换为退格、制表、换行和回车字符。它们并没有特定的图形显示，但会依不同的应用程序，而对文本显示有不同的影响。
32～126(共95个)是字符(32sp是空格），其中48～57为0到9十个阿拉伯数字；
65～90为26个大写英文字母，97～122号为26个小写英文字母，其余为一些标点符号、运算符号等
GB2312，GBK
中国人定义的双字节字符编码GB2312，收纳了7000多个中文，兼容ASCII。GBK是在GB2312的基础上扩展了，包括少数民族文字，英文字符用一个字节表示，中文字符用2个字节表示。但是GBK只能解决中国人使用的问题，全世界流通问题仍存在，于是出现了Unicode
Unicode
为了解决传统字符编码局限而产生，对世界上大部分文字系统进行编码，整理，可以容纳100多万个符号，使电脑可以更方便处理和展示文字。
采用16位编码空间，每个字符占2个字节。Unicode实现方式成为Uincode转换格式，扩展自ASCII码。Unicode有2种格式，UCS-2和UCS-4，因为全世界远不止65535种字符，所以UCS-4定义用4个字节表示一个字符。
但由于固定了字符使用字节长度，造成了浪费，如字母并不需要2个字节。
而且有些是用2个字节，有些是4个字节，存到计算机都是0和1的数字串，无法分别是这4个字节是表示两个英文字符还是一个中文字符。
所以有了后面的utf8
UTF-8
utf8是unicode的一种实现方式，一种变长的字符编码，根据规则用1-4个字节来表示一个字符，如英文是1个字节，中文是3个字节。
utf8规定：对于多字节的字符，第一个字节的前n位是1，第n+1位设为0，后面字节的前两位为10.剩余的二进制位全部用该字符的unicode码填充
以『好』为例，『好』对应的 Unicode 是597D，对应的区间是 0000 0800—0000 FFFF，因此它用 UTF-8 表示时需要用3个字节来存储，597D用二进制表示是： 0101100101111101，填充到 1110xxxx 10xxxxxx 10xxxxxx 得到 11100101 10100101 10111101，转换成16进制是 e5a5bd，因此『好』的 Unicode 码 U+597D 对应的 UTF-8 编码是 “E5A5BD”。你可以用 Python 代码来验证：
>>> a = u"好"
>>> a
u'\u597d'
>>> b = a.encode('utf-8')
>>> len(b)
3
>>> b
'\xe5\xa5\xbd'
```手机扫一扫
移动阅读更方便
你可能感兴趣的文章