• PYthon笔记三之soapUI&list&切片&元组7字典&字符串方法


    一、SOAPUI接口测试(待补充)

    二、Python的数据类型

    1、整型和浮点型

    整形也就是整数类型(int)的,在python3中都是int类型,没有什么long类型的,比如说存年龄、工资、成绩等等这样的数据就可以用int类型,有正整数、负整数和0,浮点型的也就是小数类型(folat)的,带小数点的。

    2、布尔类型
    什么是布尔类型,布尔类型就是真和假,只有这两种,True和Fasle,非真即假,除了True和False还有0和1,非0即真

    3、列表和列表操作

    这也是我们在以后的开发过程中,最常用的数据类型之一,列表也叫数组,列表定义,使用[]即可;列表里面可以再套列表,一个里面套一个列表,叫二维数组;一个里面套一个列表,里面的列表再套一个列表,这个叫三维数组,套几层就是几维,定义格式如下:

     list1 = [1,2,3,4] #一个普通的数组
     list2 = ['marry','lily',[50,'monkey']] #二维数组
     list3 = ['name','sex',['lily',124,['aaaa','bbb']]] #三维数组

     通过下标访问列表中的元素,下标从0开始计数,也就是说,比如说一个列表,有个5元素,那么它第一个元素下标就是0,第二个就是1,以此类推,字符串也有下标,和列表一样 对列表的操作,分以下几种增、删、改、查

    增:

    cities = []
    #增加
    cities.append('beiing')#在列表末尾增加一个元素
    cities.insert(0,'shanghai') #在指定的位置增加元素,原来的值后移
    cities.append('guangzhou')
    print(cities)

    运行结果如下:

    ['shanghai', 'beiing', 'guangzhou']

    删:

    cities = ['xiamen','nanjing','wuhan','beijing']
    print(cities)
    cities.pop(0) #删除指定位置的元素,不传入下标的话,删除最后一个值,传入下标删除指定位置的值
    cities.remove('beijing') #删除指定的元素
    del cities[-1] #删除指定位置的元素
    cities.clear()#清空list
    print(cities)

    运行结果如下:

    ['xiamen', 'nanjing', 'wuhan', 'beijing']
    []

    改:

    cities = ['xiamen','nanjing','wuhan','beijing']
    print
    (cities) cities[0]='nanjing'#指定下标修改,如果下标不存在报错 print(cities)

    运行结果如下:

    ['xiamen', 'nanjing', 'wuhan', 'beijing']
    ['nanjing', 'nanjing', 'wuhan', 'beijing']

    查:

    cities = ['xiamen','nanjing','wuhan','beijing']
    print
    (cities[-1])#指定位置的 print(cities.index('beijing')) #获取元素的下标,下标如果不在列表里,会报错 print(cities.count('nanjing')) #查看元素在列表中共出现了多少次

    运行结果:

    beijing
    3
    1

     4、切片

    切片,切片也就是另一种方式获取列表的值,它可以获取多个元素,可以理解为,从第几个元素开始,到第几个元素结束,获取他们之间的值,格式是name:[1:10],比如说要获取name的第一个元素到第五个元素,就可以用name[0:6],切片是不包含后面那个元素的值的,记住顾头不顾尾前面的下标如果是0的话,可以省略不写,这样写,name[:6],切片后面还有可以写一个参数,叫做步长,也就是隔多少个元素,取一次,默认可以不写,也就是隔一个取一次,切片操作也可以对字符串使用,和列表的用法一样,实例如下:

    # #切片是list取值的一种方式,当需要从冲取多个值时需要用到
    # #顾头不顾尾
    nums=['duan','wang','libo',9]
    print(nums[1:2])   #顾头不顾尾如果要去duan和wang,[1:3]
    print(nums[1:])    #如果从某个下标开始取,取到末尾结束,那么末尾的下标可以省略不写
    print(nums[:2])   #如果是从头开始取,取到后面某个下标结束,那么开头的小标可以不写
    print(nums[:])  #取所有的

    运行结果:
    ['wang']
    ['wang', 'libo', 9]
    ['duan', 'wang']
    ['duan', 'wang', 'libo', 9]


    #range(3)=range(0,3) #也是顾头不顾尾
    for i in range(0,3):
           print(i)
    
    lis=list(range(1,21))
    print(lis)
    print(lis[:10:2])#最后一个冒号后为歩长,如果不写,默认为1
    print(lis[::3])  #歩长为3
    print(lis[::-1])  #-1会生成一个新的list,不改变原list的值。如果歩长是正数,从左往右取;是负数,是从右边往左边开始取值
    print(lis[:17:-1])   #从1开始取,往右,只有1个值可取  -1倒序,开头没有指定下标,所以默认从20往左取值,顾头不顾尾,取到下标为;开头指定  则从指定处开始取
    
    运行结果:
    0
    1
    2
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
    [1, 3, 5, 7, 9]
    [1, 4, 7, 10, 13, 16, 19]
    [20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    [20, 19]
    #切片操作同样适用于字符串,字符串不能修改,可直接覆盖
    #变量分可变变量和不可变变量,字符串为不可变变量
    s='hahaha'
    print(s)
    s='black'
    print(s)
    # s[4]='o' #TypeError: 'str' object does not support item assignment
    
    运行结果如下:
    hahaha
    black

    5、元组

    元组其实和列表一样,不一样的是,元组的值不能改变,一旦创建,就不能再改变了,比如说,要存数据库的连接信息,这个连接信息在程序运行中是不能被改变的,如果变了那数据库连不上了,就程序就完犊子了,这样的就可以使用元组了,元组呢,也提示别人,看到是元组的话,就说明这个值是不能被改变的,元组的定义方式是用(),小括号;元组只有两个方法,那就是count和index

    #元组也是一个list,他和list的区别是,元组里面的元素无法修改,增、删 、改都不行;用来定义一些不允许修改的变量
    t=(1,2,4,7)
    print(type(t))
    for i in t:
         print(i)
    print(t[2:4])
    print(t[3])
    
    words=(1)#该类型现在是一个普通的变量或字符串,不是元组;如果元组中只有一个元素时,后面必须加逗号
    words1=(1,)
    words2=('abc')
    print(type(words))
    print(type(words2))
    print(type(t))
    t.index(2) #找到元素的下标
    t.count((2))#找到元素的个数
    
    运行结果如下:
    <class 'tuple'>
    1
    2
    4
    7
    (4, 7)
    7
    <class 'int'>
    <class 'str'>
    <class 'tuple'>

    6、字典
    上面说了,整形、浮点型、字符串、列表和元组,下面说个新的数据类型,字典,字典也是我们开发过程中最常用的一种数据类型;想一个问题,现在要存整个北京市的所有人的信息,每个人有姓名、年龄、性别、家庭住址、学历等等,那要是用列表存的话,那就得定义N多个数组,然后存上每个人的信息,那累死人了。。。这时候又有一种新的数据类型出现了,那就是字典,dict,全称是dictionary,它具有极快的查找速度;字典是一种key-value的数据类型,比如说要存每个人的信息,那么每个人的编号就是key,value就是每个人的信息,这样的话,一个字典就能存所有人的信息了。字典的定义使用{},大括号,每个值用“,”隔开,key和value使用“:”分隔。
    举个列子,如果用列表存每个人的信息的话,需要用两个列表,一个存人名,一个存信息:

    1 names = ['marry','amy','lily']
    2 infos = [[18,18612512981,'北京'],[20,18612512991,'山东'],[25,18612532981,'河南']]

    给一个名字,如果要查他的对应信息,那就要先从names里面找到它的位置,然后再从infos中找到它的信息,如果这个列表越长,那么它的查询速度越慢。
    如果用字典实现的话,只需要一个名字和信息对应的一个表,这样就很快的根据名字找到它对应的信息,无论这个表有多大,查找速度都不会变慢。

    1 infos = {'marry':[18,18612512981,'北京'],'amy':[20,18612512991,'山东'],'lily':[25,18612532981,'河南']}
    2 infos['marry'] #取marry的信息

    为什么dict查找速度这么快?因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字,我们要查某一个字,一个办法是把字典从第一页往后翻,直到找到我们想要的字为止,这种方法就是在list中查找元素的方法,list越大,查找越慢。
    第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码,然后直接翻到该页,找到这个字。无论找哪个字,这种查找速度都非常快,不会随着字典大小的增加而变慢,这种就是字典的实现方式。
    字典的特性:
    字典是无序的,因为它没有下标,用key来当索引,所以是无序的
    字典的key必须是唯一的,因为它是通过key来进行索引的,所以key不能重复,天生就去重
    字典的增删改查:
    增:

    #使用字典:取数据方便;速度快
    #Key  --  values  成对出现
    infos={'name':'zhangliuliang','sex':'nan','age':'18'}
    #查  两种取值方式
    print(infos.get('name'))  #取不到这个key的话就是none
    print(infos.get('phone',110))#取不到这个key的话就是none
    #print(infos['phone'])  #取不到这个key的话就报错
    
    #
    print(infos)
    infos['phone']=13120180324#增加一个键值对
    infos.setdefault('xiaojinku','2000w')#如果KEY存在的话就不动他,如果不存在就添加一个
    infos.setdefault('name','joan')#如果KEY存在的话不会修改key 值
    print(infos)
    infos['name']='joan'#如果key存在 会修改原来的值
    print(infos)
    # #字典是无序的
    
    #
    infos['name']='joy'
    print(infos)
    
    #删除
    infos.pop('name') #指定KEY来删除
    infos.popitem() #随机删除一个key
    del infos['age'] #指定key来删除
    print(infos)
    
     #方法
    print(infos.values()) #获取到所有的value
    print(infos.keys())#获取到所有的key
    print(infos.items())#获取到所有的k-v
    
    #多维字典+list的操作,一层层查找,字典用key值定位,list用下标定位
    people = {
        '田雨':{
            'age':18,
            'money':200000,
            'clothes':'100套',
            'hzp':'n多',
            'shoes':['nike','addis','lv','chanle']
        },
        '张流量':{
            '金库':'2000w',
            'house':['三环一套','4环2套'],
            'cars':    {
                    'japan':['普拉多','兰德酷路泽'],
                    'usa':['林肯','凯迪拉克','福特'],
                    'china':['五菱宏光','qq','红旗']
                }
        }
    }
    #
    print(people['张流量']['cars']['china'][1])#取到qq
    print(people['田雨']['shoes'][2])#取到lv
    print(people['张流量']['cars']['usa'])#取到usa的所有值
    #
    people['田雨']['money']=people['田雨']['money']+200   #修改
    #或者
    people['田雨']['money']+=200
    
    #
    people['田雨']['shoes'].append('匡威')
    people['张流量']['cars']['usa'].append('牧马人')
    people['田雨']['shirt']='nike'
    people['jiadan']={'age':18,
                      'sex':'woman',
                      'shoes': ['nike', 'addis', 'lv', ]
                      }
    print(people)
    print(people['张流量']['cars']['usa'])
    print(people['田雨']['shoes'][2])
    print(people['张流量']['cars']['usa'])
    #直接循环一个字典的话,循环的是 字典的key
    for p in people:
        print(p)
    #循环的时候,同时取key和value
    for k,v in people.items():
        print(k,'===>',v) #'===>'随意加的字符串用以隔开

    运行结果如下:

    zhangliuliang
    110
    {'name': 'zhangliuliang', 'sex': 'nan', 'age': '18'}
    {'phone': 13120180324, 'xiaojinku': '2000w', 'name': 'zhangliuliang', 'sex': 'nan', 'age': '18'}
    {'phone': 13120180324, 'xiaojinku': '2000w', 'name': 'joan', 'sex': 'nan', 'age': '18'}
    {'phone': 13120180324, 'xiaojinku': '2000w', 'name': 'joy', 'sex': 'nan', 'age': '18'}
    {'xiaojinku': '2000w', 'sex': 'nan'}
    dict_values(['2000w', 'nan'])
    dict_keys(['xiaojinku', 'sex'])
    dict_items([('xiaojinku', '2000w'), ('sex', 'nan')])
    qq
    lv
    ['林肯', '凯迪拉克', '福特']
    {'jiadan': {'shoes': ['nike', 'addis', 'lv'], 'sex': 'woman', 'age': 18}, '张流量': {'金库': '2000w', 'house': ['三环一套', '4环2套'], 'cars': {'japan': ['普拉多', '兰德酷路泽'], 'usa': ['林肯', '凯迪拉克', '福特', '牧马人'], 'china': ['五菱宏光', 'qq', '红旗']}}, '田雨': {'money': 200400, 'shoes': ['nike', 'addis', 'lv', 'chanle', '匡威'], 'shirt': 'nike', 'age': 18, 'clothes': '100套', 'hzp': 'n多'}}
    ['林肯', '凯迪拉克', '福特', '牧马人']
    lv
    ['林肯', '凯迪拉克', '福特', '牧马人']
    jiadan
    张流量
    田雨
    jiadan ===> {'shoes': ['nike', 'addis', 'lv'], 'sex': 'woman', 'age': 18}
    张流量 ===> {'金库': '2000w', 'house': ['三环一套', '4环2套'], 'cars': {'japan': ['普拉多', '兰德酷路泽'], 'usa': ['林肯', '凯迪拉克', '福特', '牧马人'], 'china': ['五菱宏光', 'qq', '红旗']}}
    田雨 ===> {'money': 200400, 'shoes': ['nike', 'addis', 'lv', 'chanle', '匡威'], 'shirt': 'nike', 'age': 18, 'clothes': '100套', 'hzp': 'n多'}

    7、字符串方法

    #strip() 方法用于移除字符串头尾指定的字符(默认为空格)
    a='   字 符 串    
    
    
    
    
    '
    c = a.strip()  #默认去掉字符串两边的空格和换行符
    c= a.lstrip()  #默认去掉字符串左边的空格和换行符
    c = a.rstrip() #默认去掉字符串右边的空格
    print('c...',c)
    print('a...',a)
    
    words = 'http://www.nnzHp.cn'
    print(words.strip('h')) #如果strip方法指定一个值的话,那么会去掉这个值
    print(words.count('a'))  #统计字符串出现的次数
    print(words.index('z'))  #找下标,如果元素找不到的话,会报错
    print(words.find('z')) #找下标,如果元素找不到的话,返回-1
    print(words.replace('w','W'))  #替换字符串
    print(words.isdigit()) #判断字符串是否为纯数字
    print(words.startswith('http')) #判断是否以某个字符串开头
    print(words.endswith('.jpg')) #判断是否以某个字符串结尾
    print(words.upper())  #变成大写的
    print(words.lower())  #变成小写的
    
    username = 'abcdefADS12345@#¥'
    print(username.isalpha())  #判断字符串是否全为字母
    print(username.isalnum()) #判断是否包含字母和数字,它是只要有字母或者有数字就返回true

    print(username.startswith('test'))  #判断字符串是否以xx开头,是就返回TRUE
    print(username.endswith('.xls')) # 判断字符串是否已以xx结尾,是就返回TRUE
     

    运行结果如下:

    c...    字 符 串
    a...    字 符 串    
    
    
    
    
    
    ttp://www.nnzHp.cn
    0
    13
    13
    http://WWW.nnzHp.cn
    False
    True
    False
    HTTP://WWW.NNZHP.CN
    http://www.nnzhp.cn
    False
    False
    False
    False
     
  • 相关阅读:
    C#编程思路
    将字符串类型字段转为map类型字段,使用str_to_map()函数
    写hive脚本时,如果hive的过滤条件比较多。可以把过滤条件放到一个参数里。然后把参数放到过滤条件处。这样以后只需要改参数就可以了
    linux中. 路径/文件
    inner join ,left join 会导致数据发散
    如何批量按分区插入数据
    hive表添加字段后,查不出数据是咋回事?
    linux中$0的含义
    linux中的$#含义
    linux的语法
  • 原文地址:https://www.cnblogs.com/jojoan/p/8651551.html
Copyright © 2020-2023  润新知