颠覆你的Python实践软件测试软件测试之路

【持续更新】py基础知识汇总

2017-08-22  本文已影响76人  亭子青年

这里汇总了我在跟大婶的课程过程中涉及到的所有python基础知识点，可能稍微有点杂乱，但是不影响阅读

模块和包

import --- #方法1
from --- import --- #方法2

import --- as "别名" #为模块指定别名，后续代码中直接使用别名来替代模块名

1. pip install package_name
2. easy_install package_name
3. 下载exe后缀的包执行安装
4. 下载模块压缩包，在目录下执行python setup.py install
5. 拷贝现成的模块包，放置在lib/site-packages目录下，如果可以正常import，说明就可以使用了

类

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

#python中，所有类最顶层父类都是object类，与java类似，如果定义类的时候没有写出父类，则object就是其直接父类
class Animal:
    #构造方法：当创建了这个类的实例时就会调用该方法
    def __init__(self,a,b):#类的方法必须包含参数self，self代表实例本身，当然你也可以用其他的字符来代替，比如“demo”
        self.name = a

        #python通过变量命名来区分属性和方法的访问权限

        self.__age = b #私有变量，两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时self.__private_attrs。
        print("this is animal init")

    def say(self):
        self.__private_methed() #私有方法的调用
        print("i am animal")

    #类的私有方法：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods
    def __private_methed(self):
        pass
    #对象引用基数为0，也就是对象消逝的时候被调用
    def __del__(self):
        print("this is animal del")

# 继承，python也支持多继承
class Dog(Animal):
    #重写__init__()
    def __init__(self,a,b,c):
        #继承：重写init方法的时候需要显示的调用基类的__init__()方法
        # super().__init__(self,a,b) #显示调用父类的构造方法
        Animal.__init__(self,a,b) #显示调用父类的构造方法


    #多态：如果父类方法的功能不能满足需求，可以在子类重写父类的方法。实例对象调用方法时会调用其对应子类的重写后的方法
    def say(self):
        print("i am dog")

if __name__=="__main__":
    #类实例化，可以使用其属性，可以动态的为实例对象添加属性而不印象类对象
    x =Dog(2,3,4)
    x.say()

异常处理

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

'''
学习python3中的try--except--finaly
try：运行代码
except：捕获try里面的异常是否和指定的异常类型匹配，如果匹配则执行对应except的代码，如果没有except能够匹配成功，则抛给上层
finally：不论try里面是否抛出异常，都会执行到这个子句中，同时需要注意的是，如果except,else中有抛出异常，而且没有except将其拦截住，那么这个异常会在finally子句执行之后再次被抛出
'''
import  logging

try:
    1/0
except ZeroDivisionError as  e:
    logging.exception(e)
except:
    print("else error")
finally:
    print("finally")

函数的参数

函数的参数包括“必填参数”，“默认参数”，“可变参数”，“关键字参数”，"命名关键字参数"-（这里不介绍命名关键字参数）

注意：参数的顺序：必填参数，默认参数（变化大的在前，变化小的在后），可变参数，关键字参数

必填参数:下面函数的参数为必填参数，在调用该函数的时候，必须传入这两个参数，否则会抛异常

def fun(name,password):
    pass

默认参数：就是给参数设置一个默认值，在调用该函数的时候，如果对该参数进行赋值，则使用赋值的数据进行操作，否则使用参数的默认值

def fun(a,b,c=2):
    print(a,b,c)
    
fun(1,2) #打印结果：1 2 3
fun(1,2,3) #打印结果：1 2 3

这里说明一下，默认参数必须指向不变对象，因为不变对象一旦创建，对象内部的数据就不能改变，我们在编写程序的时候，如果可以设计一个不变对象，那就尽量设计成不变对象。下面是将默认参数指向一个list的例子。

def fun02(L=[]):
    L.append("end")
    print(L)
if __name__ == "__main__":
    fun02()  #结果['end']
    fun02()  #结果['end', 'end']

可变参数：就是传入的参数个数是可变化的，可以是1个，2个，任意个，还可以是0个，这些参数在函数内部自动组装成一个tuple，一般我们默认使用*args来表示可变参数

#定义语法：*args是可变参数，也可以命名为其他，只要在名称前面加一个“*”就可以了
def fun03(a,b,c=1,*args):
    print(a,b,c,args)
    
if __name__ == "__main__":
    #调用方法1：直接传入参数
    fun03(1,2,3,4,5,6)
    #调用方法2：组装成list或者tuple，再进行传入
    args=(1,2,3)
    fun03(1,2,3,*args)

关键字参数：允许你传入0个或者任意个含参数名的参数，这些关键字参数在函数内部自动组装成一个dict，一般我们默认使用**kw来表示关键字参数

#定义语法：**kw是关键字参数，你也可以其他的名，只要在前面加两个“*”就可以了
def fun04(a,b,c=1,**kw):
    print(a,b,c,kw)
if __name__ == "__main__":
    #调用方法1：直接传入参数，方式“key = value”
    fun04(1,2,3,d = 4,e = 5 )
    #调用方法2：传递dict类型的数据
    kw = {"d":4,"e":5}
    fun04(1,2,3,**kw)

数据类型

主要介绍3中内置的数据类型：list（列表），tuple（元祖），dict（字典）

list：列表，有序的集合，可变数据类型，可以随时添加和删除其中的元素

方法 解析
mylist = [1,2,3] 申明一个list对象
mylist = [] 申明一个空的list对象
mylist.insert(0,12) 在索引0的地方插入12
mylist.append(1) 在list的末尾追加一个数据1
mylist[0] = 11 修改下标为0的数据
mylist.pop() 删除list最末尾的数据，返回删除的value
mylist.pop(0) 删除下标为0的数据，返回删除的value

tuple：元祖，有序的集合，不可变数据类型，一旦初始化了就不能修改了，因为不可变，所以更安全，“廖雪峰”官网上建议，如果能够使用tuple代替list就尽量使用tuple

方法 解析
mytuple = (1,) 申明一个只有一个元素的元祖
mytuple = (1,2,3) 申明一个有3个元素的元祖
mytuple[0] 获取元祖的元素，根据index

dict：字典，在其他语言中也称map，使用键值对存储，具有极快的查找速度，dict是用空间来换取时间的一种方式

key必须是不可变对象，常用的key是字符串。

方法 解析
mydict = {"name":"ht","password":"ting"} 申明dict
mydict["name"] = "ht2" 如果字典中存在key为name的元素，则修改对应的value值
mydict.get("name",-1) 获取key=“name”的value，如果key不存在，则返回自己设置的数据，这里设置的是-1
mydict.pop("namew",-1) 删除元素,如果指定的key不存在，则返回自己设置的数据，这里设置的是-1
if key in mydict:pass python3中使用这种方式代替了“has_key(key)”这个方法：表示判断key是不是在字典中
mydict.items() （py3）返回字典键值的可迭代对象，注意这里不是迭代器哦，一般用于循环获取键值 
from collections import Iterable
from collections import Iterator

dict01 = {"message": "获取附近服务商成功","nextPage": 1,"pageNo": 0,"resultCode": "000","totalPage": 66746}
    if "message" in dict01: #判断一个key是不是在dict里面
        print(dict01.get("message"))
    items = dict01.items() #items()
    print(isinstance(items,Iterator)) #判断是不是迭代器
    print(isinstance(items,Iterable)) #判断是不是可迭代对象
    print(items)

切片

取一个list，tuple，str的部分元素就会用到切片操作

语法：“对象”[索引:索引:步长]

if __name__ == "__main__":
    mylist = [0,1,2,3,4]
    print(mylist[0:2])  # [0, 1]
    print(mylist[0:-1]) # [0, 1, 2, 3]
    print(mylist[::2]) # [0, 2, 4]

json.loads

用法：把json格式字符串解码转换成python字典对象

import json

if __name__ == "__main__":
    json_str = '{"message": "获取附近服务商成功","nextPage": 1,"pageNo": 0,"resultCode": "000","totalPage": 66746}'
    json_ob = json.loads(json_str)
    print(json_ob)
    print(type(json_ob))

eval()

解释：将字符串str当成有效的表达式来求值并返回计算结果
语法：eval(source,[globals[,locals]])->value，一般使用source参数就可以了

if __name__ == "__main__":
    # 将list字符串转为list对象
    list_str = "[1,2,3]"
    list_rs = eval(list_str)
    print(type(list_rs))
    
    # 将tup字符串转换为tuple对象
    tup_str = "(2,3,4)"
    tup_rs=eval(tup_str)
    print(type(tup_rs))
    
    # 将dict字符串转换为dict对象
    dict_str = "{'name':'ht','pass':'123'}"
    dict_rs = eval(dict_str)
    print(type(dict_rs))
    
    # 将str当成有效表达式来求值并返回结果
    str_and = "1+2"
    print(eval(str_and))

isinstance(value,(dict,list))

说明：类型判断，判断value的类型是否属于dict和list中的一种，如果是则返回True，不是则返回False

if __name__ == "__main__":
    print(isinstance([1,2,3],list))
    print(isinstance([1,2,3],(list,tuple)))

set() 集合

说明：集合和dict比较相识，也是key的集合，但不存在value，由于key不能重复，所以，在set中，没有重复的key。set和dict一样，不可以放入可变元素，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。

方法 解析
s = set() 创建一个空的set对象
s = set([1,2,3,2]) 根据提供的可迭代对象创建一个set，这里可以是list，tuple，等
s.add(5) 添加元素到set中
s.remove(key) 删除元素
s.issubset(t) 集合的包含关系，指的是s中的每一个元素都在t中，是则返回True，否则返回False
上一篇 下一篇

猜你喜欢

热点阅读