Selenium + Python 自动化测试16（Python基础复习）

        我们的目标是：按照这一套资料学习下来，大家可以独立完成自动化测试的任务。

上一篇我们讨论了使用模块化测试的测试模型，从某一程度也反映出熟练掌握一门编程语言的重要性。

         为了后续进一步深入学习。本篇文章主要做下Python基础知识的复习。大家也可以参考着练习一遍，可以快速低恢复编写基本代码的能力。适用于一段时间没有使用python，现在做自动化测试要用到的情况。也适用面试前的准备。

一、输出与输入

1、print()

看例子学习：

print("hello selenium")  #无参数输出

name = 'dewi'
print("my name is %s"%name) #带参数输出，字符串

number=6
print("my enter number is %d"%number) #带参数输出，数字

print("my name is %s,and i enter number is %d"%(name,number))#两个参数输出

2、input 输入

favourite_color = input("pls enter your color you like:")

print("your favourite color is %r"%favourite_color) #不确定输入的内容，输出可以用%r

二、python 数据类型

数据类型：包含数字、字符串、列表、元组、字典

1、数字

数字是较广泛的数据类型：

整形    int       如： 1

浮点数  float    如： 2.1

长整型  long     如：1L， 当一个整数后面有L，那么就是长整型

正因为2版本整型的不严谨，python 3 版本取消了长整型。

print(float(5))   #类型转换，整型转化为浮点型

数字运算：

数字的运算符：+  -   *  /  % 取余  **求方  // 整除

print(1+1)   

print(4/2)  #除法，结果2.0

print(4//3) #整除，结果1

print(4%3)  #取余，结果1

2、字符串

定义：字符串是有序的，不可修改的，元素以引号包围的序列

符号：' ' 单引号   " "  双引号   ''' '''  三单  """  """  三双

用不同的引号可以避免字符串中有'   "  等符号的情况，交叉使用

a = "abcdefg"

print(a[1])     #输出为b,序号从0开始

#截取，有下限没有上限

a="abcdefg"

print(a[1:3])     #打印出bc

3、列表

字符串是一个不可以修改的序列，当我们对字符串修改的时候，实际上是生成了一个新的被修改的对象，而原字符串没有变化。但是列表是一个可以修改的序列，会修改到他本身

所以，我们需要变量指出。

赋值有三种：

1，直接赋值  a = 1

2，链式赋值   a = b =1

3, 序列解包赋值   a,b = 1,2   等号左边的和右边的值数量要一致

列表定义：是一个有序的，可以修改的，元素以逗号分隔，以中括号包围的序列。

列表的定义：

（1）list

（2）[ ]

（3）range

（4）xrange

python 3 取消了xrange,  range 和xrange 效果一样

list1=['a','b','c','d','e','f']
print(list1[3]) #输出d

#列表的修改
ourlist = list('12345')
print(ourlist)
ourlist[0] = 'a'
print(ourlist)

输出：['a', '2', '3', '4', '5']

4、元组

元组的定义：元组是元素以逗号分隔，以小括号包围的有序的，不可以修改的序列。

ourtuple=tuple("12345")
print(ourtuple)
输出：('1', '2', '3', '4', '5')

元组和字符串的区别：都是不可以修改的序列，

元组的元素可以使用任何元素，字符串的元素为字符

元组的元素长度可以是任意的，字符串的元素长度只能为1

5、字典

字典定义：一个无序的，可以修改的序列

元素键值对的形式，以大括号包围的无序的序列。字典是python的基础数据类型当中唯一一个映射关系的数据类型，通常对应JSON。

  定义：{1：“a”,2:"b",3:"c"}

  zip  函数 将几个序列对应索引上的元素分到一个元组当中，形成一个大元组，子元组的个数取决于最短序列的长度

mydict = {'name':'zhangdan','password':888888}
print(mydict)

print(mydict.keys())
print(mydict.values())

输出：

dict_keys(['name', 'password'])

dict_values(['zhangdan', 888888])

字典的特点

因为字典是无序的，所以字典没有索引值，因为字典没有索引值，所以字典以键取值，字典的键相当于列表的索引

因为字典以键取值，所以字典的键唯一且不可以修改。不可以重复

字典的方法：

字典到的取值	Keys	获取字典所有的键
	values	获取字典所有的值

#循环打印key,value值

for key,value in mydict.items():

    print("mydict keys is %r"%key)

    print("mydict values is %r" % value)

输出：

mydict keys is 'name'

mydict values is 'zhangdan'

mydict keys is 'password'

mydict values is 888888

#zip 方法举例

keys =["d",'c','a']

values=[3,5,7]

for key,value in zip(keys,values):

    print(key,value)

输出：

d 3

c 5

a 7

三、流程控制

1、if语句

if  语句：

if语句判断语句，只有满足if 条件才执行if下的语句块

if   elif   else

if(条件)：

    block  语句块

elif(条件)：                       #可以有多个

    block  语句块

else:

    block 语句块

#举例，if   elif  else 用法

scores = 88

if scores>90:

    print("A")

elif scores>80:

    print("B")

elif scores>70:

    print("C")

elif scores>60:

    print("D")

else:

    print("E")

2、for 循环

python  当中的for循环，与其他语言不通。

其它语言：

for(var int  i =1;i<6;i++)

{

         block

}

python 语言： 

for  in 结构

for  变量  in   可迭代对象：

         block

for 循环实质上是将后面可以迭代的对象元素依次赋值给前面的变量，每赋值一次就执行一次

#for 用法举例

for i in range(1,10,2):    #1-10，不包括10,步长2

    print(i)

输出：1、3、5、7、9

四、函数和类

1、函数

定义：就是将我们要执行的代码进行结构整合，形成可以被调用的代码块，这个代码块就是函数

函数是可以重复调用的代码块

函数比较代码复制：

1，减少冗余代码

2，代码结构清晰

3，有助于保持代码的一致性

函数包含内容如下：

1）关键字  def 

2） 函数名  ：字母开头，不允许有关键字，不允许有特殊符号，不允许有莫名其妙的a,b等函数名

3）参数：定义在参数括号里，调用时传入，作用在函数内部的变量

(1)如果有写在括号中

(2)没有就写空括号

4）内容块

#函数举例

def add(m,n):

    return m+n

print(add(6,9))  #输出15

2、类和实例

1）类的结构形式：

class person(object):

    #类的语句块

    pass

#class 类名（基类）：

#object是我们python里面所有类的基类

# person是有object发展而来。3.0默认全部继承object类

2）类的实例

#新建一个符合这个类的标准的一个类的实例对象

#类的实例就是： 实例 = 类名()

xiaohong = person()

xiaoming = person()

#类的成员函数是定义在类这个块里，说明：

（1）第一个参数是self，

（2）调用成员函数不一样

（3）类的成员函数是一个全局的函数，全局唯一，不会随着类的实例化多个而出现多个

（4）@property 修饰的方法或成员函数

      1，方法必须只能self参数，不能有其他

      2，方法调用时不可以写（）

3）简单点的例子：

class Cal(object):

    def __init__(self,m,n):
        self.m = m
        self.n = n


    def add(self):
        return self.m+self.n 

calculate = Cal(7,8)

print(calculate.add())

输出：15

4）复杂点的例子：

类的实例：

1，类的实例有一个字典对象，用来保存key，value

2，可以在类的成员函数中使用self.key来访问和存储类的实例的成员变量

3.外部直接可以使用对象的实例.数据成员来获取数据成员的值

dir 函数

1.不带参数时，返回当前范围内的变量，方法和定义的类型列表

2.带参数时，返回参数的属性、方法列表

3.dir（类的实例）里面有一个__dict__的字典，原来存的都是类实例的数据成员

例如：

class person(object):


    def init_person(self, age, name, sex):

        self.age = age

        self.name = name

        self.sex = sex

        print(self.name)


    @property

    def get_age(self):

        print(self.age)

        pass

    pass



# 新建一个符合这个类的标准的一个类的实例对象

# 类的实例就是 实例 = 类名()

xiaohong = person()

xiaoming = person()



# 类的成员函数

# 调用成员函数不一样，完成具体的事情

# 类的实例.函数名称（参数）

# 类的成员函数调用的时候不用我们传self参数，python解释器在执行的时候默认传递

# self传的类的实例

# self 会在函数调用的时候传递

xiaohong.init_person(10, "xiaohong", "girl")

xiaoming.init_person(11, "xiaoming", "boy")

# 错误的调用xiaoming.get_age()

xiaoming.get_age      #正确调用

# 调用成员变量

print(xiaohong.sex)

print(dir())

print(dir(xiaohong))

print(xiaohong.__dict__)

print(xiaoming.__dict__)

输出：

xiaohong

xiaoming

11

girl

['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'add', 'i', 'key', 'keys', 'list1', 'mydict', 'name', 'number', 'ourlist', 'ourtuple', 'person', 'scores', 'value', 'values', 'xiaohong', 'xiaoming']

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'get_age', 'init_person', 'name', 'sex']

{'age': 10, 'name': 'xiaohong', 'sex': 'girl'}

{'age': 11, 'name': 'xiaoming', 'sex': 'boy'}

今天就先学习到这里吧。

每天进步一点点，加油！