zoukankan      html  css  js  c++  java
  • 【python教程】2、列表、元组、字符串、字典

    一、列表

    1、函数 list:它实际上是一个类,可将任何序列作为 list 的参数

    # 1、函数list
    a = list('abc')
    print(a)  # a结果为:['a','b','c']
    
    # 2、将字符列表转化为字符串
    print(''.join(a))  # 结果为:'abc'
    print('1'.join(a))  # 结果为:'a1b1c'
    

    2、修改列表的方式:给元素/切片赋值、删除元素

    # 1、给元素赋值
    x = [1,1,1,1]
    x[1] = 2  # x为:[1,2,1,1],注意不能给不存在的元素赋值
    
    # 2、删除元素
    del x[1]  # x为:[1,1,1]
    
    # 3、给切片赋值
    x[1:] = [2,2]  # x为:[1,2,2]
    x[2:] = [3,4,5]  # x为:[1,2,3,4,5],使用切片赋值,可将切片切换为长度与其不同的序列
    x[1:1] = [0,0]  # x为:[1,0,0,2,3,4,5],可在不替换原有元素的情况下插入新元素
    x[1,2] = []  # x为:[1,2,3,4,5],替换一个空切片,来删除切片
    

    3、列表方法

    方法是与对象联系紧密的函数。方法调用和函数调用很像,只是在方法名前加上了对象和句点。

    lst = [1,2,3]
    # 1、增加元素
    lst.append(4)  # 增加元素,lst为:[1,2,3,4]
    lst.extend(1,2,3,4)  # 扩展列表
    lst.insert(1, 'test')  # 将一个对象插入列表,lst值为:[1,'test',2,3,4,1,2,3,4]
    ls = [1,2] + [2,3]  # 拼接列表,返回新的序列
    
    # 2、删除元素
    i = lst.pop()  # 从列表中删除最后一个元素(栈,后进先出LIFO),并返回这个元素
    i = lst.pop(0)  # 先进先出
    lst.remove('test')  # 删除第一个为指定值的元素
    lst.clear()  # 清空列表的内容,类似与切片赋值语句 lst[:] = []
    
    l = [1,2,3]
    # 3、元素排序
    l.reverse()  # 按相反的顺序排列列表中的顺序,不返回值
    list(reversed(l))  # 函数reversed,按相反的顺序迭代序列,返回一个迭代器
    l.sort()  # 对列表就地排序,参数reverse=True(默认值)表示正序
    n = sorted(l)  # 返回一个排过序的列表
    # 高级排序
    x = ['a','abc','ab']
    x.sort(key=len)  # 根据元素长度进行排序(使用len函数为每个元素创建一个键,再按键排序)
    
    ls.index(2)  # 查找指定值第一次出现的索引
    lst.count(1)  # 计算指定元素在列表中出现的次数
    
    a = [1,2,3]
    b = a  # 将b关联到列表
    b[2] = 0  # a为:[1,2,0]
    c = a.copy()  # 类似于a[:]和list(a);a和c指向不同的列表
    c[2] = -1  # a为:[1,2,-1]
    
    squares = [value**2 for value in range(1,11)]  # 列表解析
    

    二、元组

    元组:不可修改的序列。使用圆括号来标识。只包含一个值的元组,必须再这个值后面加上逗号。

    x = 1, 2, 3  # 元组的定义
    y = (1,)
    z = tuple('abc')
    
    a = 3 * (1 + 1,)  # a的值为:(2, 2, 2)
    print(a[1])  # a[1]=2,用索引访问元素
    
    # 修改元组变量。虽然不能修改元组的元素,但可以给存储元组的变量重新赋值
    d = (200, 50)
    d = (400, 100)
    

    三、字符串

    字符串是不可变的,所以给元素或切片赋值都是非法的。用引号括起的都是字符串,可以是单引号,也可以是双引号。

    字符串的方法很多,其中很多都是继承自模块string。(在较早的python版本中,这些方法是string中的函数)。模块string中有一些字符串没有的常量和函数,如 string.digits。

    'world'.center(10)  # 在两边添加填充字符让字符串居中,默认为空格
    'world'.center(10, '-')
    
    '12345'.find('23')  # 在字符串中查找子串,找到就返回子串第一个字符的索引,否则返回-1
    print('a' in 'abc')  # 检查单个字符是否在序列中,返回True和False
    
    seq = ['1', '2', '3', '4']
    print('+'.join(seq))  # 结果为'1+2+3+4',join合并序列的元素(元素须为字符串)
    dirs = '', 'usr', 'bin', 'env'
    print('C' + '\'.join(dirs))  # 结果为:C:usrinenv
    
    print('/usr/bin/env'.split('/'))  # 结果为:['', 'usr', 'bin', 'env']
    print('a b c'.split())  # 结果为:['a', 'b', 'c']
    
    # title():词首大写
    # upper()/lower():将字符串改为全部大写或全部小写
    string.capwords("that's all, folks")  # 词首大写
    
    print('ab c de'.replace('ab', 'b'))  # 将指定子串替换为另一个字符串
    
    # rstrip():删除末尾空白(空白:泛指任何非打印字符。空格、制表符	和换行符
    )
    # lstrip():删除开头空白
    # strip():删除两端空白
    print('***ab*cd!!**'.strip('!*'))  # 删除两端的指定字符,结果为ab*cd
    
    # isspace()、isdigit()、isupper():字符是否全为空白、数字、大写,是返回True,否则返回False
    

    四、字典

    字典是python中唯一的内置映射类型,其中的值不按顺序排列,而是存储在键下。键可能是数、字符串或元组。键必须是独一无二的。

    Python不关心键—值对的存储顺序,而只跟踪键和值之间的关联关系。

    # 1、函数dict()
    items = [('name', 'lisa')]
    print(dict(items))  # 结果为:{'name': 'lisa'}
    d = dict(name='lisi', age=42)  # 使用关键字实参调用这个函数,d为{'name': 'lisa', 'age':42}
    d1 = dict()  # d1为{}
    
    # 2、基本的字典操作(字典的基本行为在很多方面都类似于序列)
    # len(d);d[k];d[k] = v;del d[k];k in d(检查字典是否包含指定的键的效率更高,数据结构越大,效率差别越大)
    # 键的类型:可以是任何不可变的类型,如实数,字符串或元组
    
    # 3、将字符串格式设置功能用于字典
    phonebook = {'beth': '9102', 'ceil': '3258'}
    print("ceil's phone nember is {ceil}." .format_map(phonebook))
    

    字典的方法:

    x = {'name': 'amy', 'machines': ['foo', 'bar']}
    
    # 1、copy浅赋值(替换副本中的值,原件不受影响;修改副本中的值,原件也将修改)
    y = x.copy()  # copy返回一个新字典,其包含的键值对于原来的字典相同。
    y['name'] = 'ame'
    y['machines'].remove('bar')
    print(x, y)  # x={'name': 'amy', 'machines': ['foo']}; y={'name': 'ame', 'machines': ['foo']}
    
    # 2、deepcopy深复制(同时复制值及其包含的所有值)
    from copy import deepcopy
    dc = deepcopy(x)
    x['age'] = 18
    print(dc, y)  # dc={'name': 'amy', 'machines': ['foo']}; y={'name': 'amy', 'machines': ['foo'], 'age': 18};
    
    # 3、fromkeys 创建一个新字典,包含指定的键,每个键对应的值都是None
    {}.fromkeys(['name', 'age'])  # 结果为{'name':None, 'age': None}
    dict.fromkeys(['name', 'age'])  # 直接对dict调用fromkeys(dict是所有字典所属的类型),结果为{'name':None, 'age': None}
    dict.fromkeys(['name', 'age'],'(unknown)')  # 不使用默认值None,提供特定值unknown
    
    # 4、get
    d = {}
    print(d['age'])  # 访问字典中没有的项,会引发错误
    print(d.get('age'))  # 不会引发异常,而是返回Nona。可指定默认值:d.get('age', 'N/A')
    
    # 5、items 返回一个包含所有字典项的列表,其中每个元素都为(key, value)的形式
    p = {'name': 'lisa', 'age':42}
    it = p.items())  # it=dict_items([('name': 'lisa'), ('age':42)]),这是一种名为字典视图的特殊类型,可用于迭代
    # 字典视图的用法:len(it)、 ('age':42) in it、list(p.items())
    
    # 6、keys 返回一个字典视图,其中包含指定字典中的键
    
    # 7、pop 获取指定键相关联的值,并将该键值对从字典中删除
    d = {'x': 1, 'y': 2}
    print(d.pop('x'))  # 打印1,且d={'y': 2}
    
    # 8、popitem 随机弹出一个字典项,因为字典项的顺序是不确定的
    print(d.popitem())  # 结果为: {'y': 2}, d={}
    
    # 9、setdefault 获取与指定键相关联的值。在字典不包含指定键时,在字典中添加指定的键值对
    d = {}
    d.setdefault('name', 'N/A')  # 打印:'N/A',d={'name': 'N/A'}
    d.['name'] = 'ada'
    print(d.setdefault('name', 'N/A'))  # 打印:'ada'
    
    # 10、update 使用一个字典中的项来更新另一个字典
    d = {'x': 1, 'y': 2, 'z': 3}
    t = {'x': 3, 'y': 3}
    d.updata(x)  # d={'x': 3, 'y': 3, 'z': 3}
    
    # 11、values 返回一个由字典中的值组成的字典视图
    d={'x': 2, 'y': 3, 'z': 3}
    print(d.values())  # 打印:dict_values([2, 3, 3])
    
    # 12、clear
    r = x.clear()  # clear删除所有的字典项,d={},r=None
    

    常用操作

    # 删除键—值对值对
    del alien_0['points'] # 彻底删除
    
    # 遍历键—值对值
    for key, value in user_0.items():  # 将每个键—值对存储到指定的两个变量中,items():把字典中每对key和value组成一个元组,并把元组放在列表中返回
    
    # 遍历键
    for name in favorite_languages:
    for name in favorite_languages.keys():  # keys()并非只能用于遍历;它会返回一个列表,包含字典中的所有键
    
    # 遍历值,使用方法values()
    for language in set(favorite_languages.values()):  # 去重:对列表调用set(),可找出列表中独一无二的元素,并创建一个集合
    
    # 嵌套:字典列表、在字典中存储列表、在字典中存储字典
    
  • 相关阅读:
    Unity The Method Signature Matching Rule
    Unity The Property Matching Rule
    Unity The Type Matching Rule
    Unity The Custom Attribute Matching Rule
    Unity The Member Name Matching Rule
    Unity No Policies
    Unity The Return Type Matching Rule
    Unity The Parameter Type Matching Rule
    Unity The Namespace Matching Rule
    关于TSQL递归查询的(转)
  • 原文地址:https://www.cnblogs.com/mind18/p/15034599.html
Copyright © 2011-2022 走看看