精华内容
下载资源
问答
  • 列表元组字符串

    2020-07-28 20:55:27
    1.列表是有序集合,没有固定大小,能够保存任意数量任意类型的 Python 对象,语法为 [元素1, 元素2, …, 元素n]。 2.列表定义:a = [1,2,3] 3.列表内容可更改 (mutable),因此附加 (append, extend)、插入 (insert)...

    1.列表是有序集合,没有固定大小,能够保存任意数量任意类型的 Python 对象,语法为 [元素1, 元素2, …, 元素n]。
    2.列表定义:a = [1,2,3]
    3.列表内容可更改 (mutable),因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。
    list.append(obj) 在列表末尾添加新的对象,只接受一个参数,参数可以是任何数据类型,被追加的元素在 list 中保持着原结构类型。
    list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
    list.insert(index, obj) 在编号 index 位置插入 obj。
    list.remove(obj) 移除列表中某个值的第一个匹配项
    list.pop([index=-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
    4.获取列表中的元素
    通过元素的索引值,从列表获取单个元素,注意,列表索引值是从0开始的。通过将索引指定为-1,可让Python返回最后一个列表元素,索引 -2 返回倒数第二个列表元素,以此类推。
    5.切片
    切片的通用写法是 start : stop : step;最后把 step 设为 -1,相当于将列表反向排列。
    6.列表的常用操作符
    列表拼接有两种方式,用「加号 +」和「乘号 *」,前者首尾拼接,后者复制拼接。
    list.count(obj) 统计某个元素在列表中出现的次数
    list.sort(key=None, reverse=False) 对原列表进行排序。reverse – 排序规则,reverse = True 降序, reverse = False 升序(默认)。
    7.「元组」定义语法为:(元素1, 元素2, …, 元素n)
    Python 的元组与列表类似,不同之处在于tuple被创建后就不能对其进行修改。
    元组使用小括号,列表使用方括号。元组与列表类似,也用整数来对它进行索引 (indexing) 和切片 (slicing)。
    元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用。
    8.元组大小和内容都不可更改,因此只有 count 和 index 两种方法。
    9.解压(unpack)一维元组(有几个元素左边括号定义几个变量)。
    如果不关心后面的变量,可以用符号代替,例子如下:
    在这里插入图片描述
    10.字符串的定义支持使用成对的单引号或双引号。
    如果字符串中需要出现单引号或双引号,可以使用转义符号\对字符串中的符号进行转义。
    11.字符串的切片与拼接
    类似于元组具有不可修改性
    从 0 开始
    切片通常写成 start:end 这种形式,包括「start 索引」对应的元素,不包括「end索引」对应的元素。索引值可正可负,正索引从 0 开始,从左往右;负索引从 -1 开始,从右往左。使用负数索引时,会从最后一个元素开始计数。最后一个元素的位置编号是 -1。
    12. 字符串的常用内置方法
    13. 字符串的常用内置方法
    lower() 转换字符串中所有大写字符为小写。
    upper() 转换字符串中的小写字母为大写。
    swapcase() 将字符串中大写转换为小写,小写转换为大写。
    endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串 suffix 结束,如果是,返回 True,否则返回 False。如果 beg 和 end 指定值,则在指定范围内检查。
    startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串 substr 开头,如果是,返回 True,否则返回 False。如果 beg 和 end 指定值,则在指定范围内检查。
    lstrip([chars]) 截掉字符串左边的空格或指定字符。
    rstrip([chars]) 删除字符串末尾的空格或指定字符。strip([chars]) 在字符串上执行lstrip()和rstrip()。
    split(str="", num) 不带参数默认是以空格为分隔符切片字符串,如果num参数有设置,则仅分隔num个子字符串,返回切片后的子字符串拼接的列表。
    14.字符串格式化
    format 格式化函数
    在这里插入图片描述

    展开全文
  • Python列表元组字符串
  • 列表是Python中的一种数据结构,它可以存储不同类型的数据。 列表索引是从0开始的,我们可以通过下标索引的方式来访问列表中的值。
  • 列表 元组 字符串

    2020-07-28 22:06:58
    字符串<class ‘str’> 1、列表 列表是有序集合,没有固定大小,能够保存任意数量任意类型的 Python 对象,语法为 [元素1, 元素2, …, 元素n]。 关键点是「中括号 []」和「逗号 ,」 中括号 把所有元素绑在一起...

    容器数据类型

    列表<class ‘list’>
    元组<class ‘tuple’>
    字符串<class ‘str’>
    1、列表
    列表是有序集合,没有固定大小,能够保存任意数量任意类型的 Python 对象,语法为 [元素1, 元素2, …, 元素n]。
    关键点是「中括号 []」和「逗号 ,」
    中括号 把所有元素绑在一起
    逗号 将每个元素一一分开
    2、元组
    「元组」定义语法为:(元素1, 元素2, …, 元素n)
    小括号把所有元素绑在一起
    逗号将每个元素一一分开
    Python 的元组与列表类似,不同之处在于tuple被创建后就不能对其进行修改,类似字符串。
    元组使用小括号,列表使用方括号。
    元组与列表类似,也用整数来对它进行索引 (indexing) 和切片 (slicing)。
    3、字符串
    Python 中字符串被定义为引号之间的字符集合。
    Python 支持使用成对的 单引号 或 双引号。

    展开全文
  • 主要介绍了Python字符串列表元组、字典、集合,结合实例形式详细分析了Python字符串列表元组、字典、集合常见函数使用方法及相关操作注意事项,需要的朋友可以参考下
  • 文章目录1、列表 list1.1、len()1.2、max()和min()1.3、reverse()1.4、sort()1.5、clear()1.6、remove()1.7、insert()和pop()2、元组 tuple2.1、len()2.2、count()2.4、index()3、字典3.1、clear()3.2、keys()和...


    1、列表 list

    列表(list):专门用于存储一串信息,列表用中括号[]定义,数据之间使用逗号,分隔

    list1 = ['physics', 'chemistry', 1997, 2000]
    list2 = [1, 2, 3, 4, 5]
    list3 = ["a", "b", "c", "d"]
    

    1.1、len()

    获取列表的长度

    print(len(list1))
    print(len(list2))
    print(len(list3))
    

    在这里插入图片描述


    1.2、max()和min()

    获取列表中最大值和最小值

    print("----list2------")
    print(max(list2))
    print(min(list2))
    
    print("----list3------")
    print(max(list3))
    print(min(list3))
    

    在这里插入图片描述


    1.3、reverse()

    反向列表中元素

    print("----list2------")
    list2.reverse()
    print(list2)
    
    print("----list3------")
    list3.reverse()
    print(list3)
    

    在这里插入图片描述


    1.4、sort()

    对列表进行排序,从小到大

    list1 = ['physics', 'chemistry', 1997, 2000]
    list2 = [1, 4, 5, 2, 3]
    list3 = ["c", "d", "a", "b"]
    
    
    print("----list2------")
    list2.sort()
    print(list2)
    
    print("----list3------")
    list3.sort()
    print(list3)
    

    在这里插入图片描述


    1.5、clear()

    清空列表

    print("----list2------")
    list2.clear()
    print(list2)
    
    print("----list3------")
    list3.clear()
    print(list3)
    

    在这里插入图片描述


    1.6、remove()

    删除指定值

    list1 = ['physics', 'chemistry', 1997, 2000]
    list2 = [1, 2, 3, 4, 5]
    list3 = ["a", "b", "c", "d"]
    
    print(list2)
    list2.remove(2)
    print(list2)
    

    在这里插入图片描述


    1.7、insert()和pop()

    pop 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
    insert 插入对象

    list = ["a","b","c","d"]
    
    list.pop()
    print(list)
    
    #指定索引位置进行插入
    list.insert(2,"ppx")
    print(list)
    

    在这里插入图片描述


    2、元组 tuple

    tuple元组和列表类似,不同的地方是元组元素不能修改

    tup1 = (1, 2, 5 ,3, 4, 2 ,4 ,2)
    

    2.1、len()

    获取元组的长度

    print(len(tup1))
    

    在这里插入图片描述


    2.2、count()

    统计某元素出现的次数

    print(tup1.count(2))
    

    在这里插入图片描述


    2.4、index()

    获取指定元素的最小索引

    print(tup1.index(2))
    

    在这里插入图片描述


    3、字典

    字典是一个无序的,可修改的,以键值对存储的(键必须是不可修改类型且键不可重复,值没有要求)数据类型

    dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
    

    3.1、clear()

    清空字典

    print(dict)
    dict.clear()
    print(dict)
    

    在这里插入图片描述


    3.2、keys()和values()

    keys以列表返回一个字典所有的键

    keys = dict.keys()
    
    for key in keys:
        print(key)
    

    在这里插入图片描述

    values以列表返回字典中的所有值

    values = dict.values()
    
    for value in values:
        print(value)
    

    在这里插入图片描述


    3.3、items()

    以列表返回可遍历的(键, 值) 元组数组

    for k,v in dict.items():
        print(k+"-"+v)
    

    在这里插入图片描述


    3.4、get()

    返回指定键的值,如果值不在字典中返回default值

    print(dict.get("Alice"))
    print(dict.get("afaawg"))
    

    在这里插入图片描述


    3.5、pop()

    删除指定键值

    print(dict)
    dict.pop("Beth")
    

    在这里插入图片描述


    3.6、setdefault()

    若字典中有该键,则不做任何操作,若没有则添加上

    dict.setdefault("Alice","皮皮虾")
    dict.setdefault("xxx","xxx")
    print(dict)
    

    在这里插入图片描述


    4、字符串

    只要是是使用单引号,双引号,三引号包裹起来的数据都是字符串


    4.1、replace()

    字符串替换

    str = "hello world hello ppx"
    
    #将hello替换成皮皮虾
    print(str.replace("hello","皮皮虾"))
    

    在这里插入图片描述


    4.2、split()

    字符串分割

    str = "hello world hello ppx"
    
    #使用空格进行分割
    string = str.split(" ")
    print(string)
    

    4.3、strip()

    自定义删除字符串两边的东西,默认是空格
    lstrip()去除字符串左边空格 rstrip()去除字符串右边空格

    str = "        hello world hello ppx"
    
    print(str)
    #去除字符串两边的空格
    string = str.strip()
    print(string)
    
    #去除字符串两边的x
    s = str.strip("x")
    print(s)![在这里插入图片描述](https://img-blog.csdnimg.cn/20200905162224508.png#pic_center)
    
    

    在这里插入图片描述


    4.4、count()

    str = "        hello world hello ppx"
    
    #默认全部查找
    print(str.count("o"))
    #自定义范围查找
    print(str.count("o",0,20))
    

    在这里插入图片描述


    4.5、find()

    str = "hello world hello ppx"
    
    #默认全部查找
    print(str.find("l"))
    #指定范围查找
    print(str.find("l",0,1))
    

    在这里插入图片描述

    返回-1表示没有找到


    4.6、join()

    list = ["a","b","c","d"]
    
    print("-".join(list))
    

    在这里插入图片描述



    CSDN独家福利降临!!!


    最近CSDN有个独家出品的活动,也就是下面的《Python的全栈知识图谱》,路线规划的非常详细,尺寸 是870mm x 560mm 小伙伴们可以按照上面的流程进行系统的学习,不要像我当初一样没人带自己随便找本书乱学,系统的有规律的学习,它的基础才是最扎实的,在我们这行,《基础不牢,地动山摇》尤其明显。

    最后,如果有兴趣的小伙伴们可以酌情购买,为未来铺好道路!!!

    在这里插入图片描述


    博主会持续更新,有兴趣的小伙伴可以点赞、关注和收藏下哦,你们的支持就是我创作最大的动力!

    更多博主开源爬虫教程目录索引(宝藏教程,你值得拥有!)

    在这里插入图片描述

    展开全文
  • List列表 list(列表)是python中使用最频繁的数据类型。专门存放数据,存放其中的数据被称作元素。 列表⽤ [ ] 定义,元素 之间使⽤ , 分隔。 列表的 索引 从 0 开始。 索引 就是元素在 列表 中的位置编号。 a = [1...

    作者今天在复习数据类型,想着就把这些内置的方法给集中一下,方便查看。这些都是作者认为比较常用的,不足之处,请见谅。

    List列表

    list(列表)是python中使用最频繁的数据类型。专门存放数据,存放其中的数据被称作元素

    • 列表⽤ [ ] 定义,元素 之间使⽤ , 分隔。
    • 列表的 索引 从 0 开始。
    • 索引 就是元素在 列表 中的位置编号。
    a = [1, 2, 3]
    print(a[0])
    print(a[1])
    print(a[2])
    

    列表常用的操作

    增加元素

    • 列表.append(数据)在列表末尾添加元素。
    • 列表.insert(索引,数据)在列表指定位置插入元素。
    • 列表.extend(可迭代对象)将可迭代对象中的元素 追加到列表中。
    a = [1, 2, 3]
    a.insert(0, 4)  # 在开始加入4
    a.append(5)  # 在最后加入5
    a.extend('abc')
    print(a)
    

    删除元素

    • 列表.remove(数据) 删除第⼀个出现的指定数据
    • del 列表[索引] 删除指定索引的数据
    • 列表.pop(索引) 删除指定索引数据,返回被删除的元素,默认表尾
    • 列表.clear() 清空列表
    a = [1, 3, 1, 3]
    a.remove(3)  # 移除第一个3
    print(a)
    del a[0]  # 移除索引为0的元素
    print(a)
    print(a.pop(0))  # 返回1
    a.clear() # 清空列表
    

    修改元素

    列表[索引] = 数据 修改指定索引的数据,数据不存在会报错.

    查询元素

    • 列表[索引] 根据索引取值,索引不存在会报错
    • 列表.index(数据) 根据查询索引,返回⾸次出现时的索引,没有查到会报错
    • 列表.count(数据) 数据在列表中出现的次数
    • len(列表) 列表⻓度
    • if 数据 in 列表: 检查列表中是否包含某元素
    a = [1, 2, 3]
    print(a.index(3))  # 2
    print(a.count(3))  # 1
    print(len(a))  # 3
    if 2 in a:
    	print('hahaha')
    

    排序

    • 列表.sort()默认升序,将参数reverse设为True降序
    • 列表.reverse() 逆序
    a = [1, 8, 9]
    a.sort()  # 默认升序
    print(a)
    a.sort(reverse=True)  # 降序
    print(a)
    a.reverse()
    print(a)  # 逆序
    

    python列表切片截取

    >>>L = ['Google', 'Runoob', 'Taobao']
     
    >>> L[2] 'Taobao'
     
    >>> L[-2] 'Runoob'
     
    >>> L[1:] ['Runoob', 'Taobao']
     
    >>>
    

    列表总结的大概就这多!!!

    元组

    元组定义

    python元组与列表类似,不同之处在于元组的元素不可更改。元组⽤ () 定义 ,⽤于存储 ⼀串数据,元素 之间使⽤ , 分隔 。元组的索引 从 0 开始 。

    # 定义元组
     
    info_tuple = ("Scrat", 18, 1.75)
     
    # 取出元素的值
     
    print(info_tuple[0]) # 输出:Scrat
    

    元组中 只包含⼀个元素 时,需要 在元素后⾯添加逗号

    • info_tuple = (50, )

    元组常⽤操作

    Tuple (元组)与列表类似,不同之处在于元组的 元素不能修改

    • info_tuple = (“Scrat”, 18, 1.75)
    • info_tuple[0] = “lisi” # 程序报错

    查询

    • 元组[索引] 根据索引取值,索引不存在会报错
    • 元组.index(数据) 根据值查询索引,返回⾸次出现时的索引,没有查到会报错
    • 元组.count(数据) 数据在元组中出现的次数
    • len(列表) 元组⻓度
    • if 数据 in 元组: 检查元组中是否包含某元素

    遍历

    • for 元素 in 元组: 取出元组中的每个元素

    让列表不可以被修改,以保护数据安全

    # 元组和列表之间的转换
     
    # 使⽤ `tuple` 函数 把列表转换成元组
     
    list1 = [10, 11]
     
    tuple1 = tuple(list1)
     
    # 使⽤ `list` 函数 把元组转换成列表
     
    # list1 = list(tuple1)
    

    元组内置函数

    1 cmp(tuple1, tuple2)
    比较两个元组元素。

    2 len(tuple)
    计算元组元素个数。

    3 max(tuple)
    返回元组中元素最大值。

    4 min(tuple)
    返回元组中元素最小值。

    5 tuple(seq)
    将列表转换为元组。

    字典

    dictionary (字典)是除列表以外 Python之中最灵活的数据类型 ,字典同样可以⽤来存储多个数据 ,通常⽤于存储描述⼀个物体的相关信息 ,字典⽤ { } 定义 。

    字典使⽤ 键值对 存储数据,键值对之间使⽤ , 分隔:

    • 键key是索引
    • 值value是数据
    • 键值之间用:分离
    • 值可以是任何类型,键只能是字符串,数字或者元组。
    a={1:2, 'a': 'as', ('as','s'):'x'}
    print(a[1])
    print(a['a'])
    print(a[('as','s')])
    
    • 键值必须唯一

    字典常用操作

    1.增

    • 字典[键] = 数据 键不存在,会添加键值对;键存在,会修改键值对的值 。

    2.删

    • del 字典[键] 删除指定的键值对 。
    • 字典.pop(键) 删除指定键值对,返回被删除的值 。
    • 字典.popitem()随机返回并删除最后一个元素。
    • 字典.clear 清空字典 。
    a = {'name': 'LIHUA',
         'age': 18,
         'sex': '男'}
    # b = a.pop('name')  # 返回移除的指定键对应的值
    # print(b)
    # print(a)
    
    # print(a)
    # a.clear()  # 清空字典
    # print(a)
    

    3.改

    • 字典[键] = 数据 键不存在,会添加键值对;键存在,会修改键值对的值 。
    • 字典.setdefault(键,数据) 键值对不存在,添加键值对;存在则不做处理 。
    • 字典1.update(字典2) 取出字典2的键值对赋值给字典1,若有相同的项则进行覆盖,不同的就添加。
    a1 = {'name': 'lihua',
          'age': 18,
          'sex': '男',
          '学号': 123456}
    a2 = {'name': 'zzh',
          'age': 16,
          'sex': '男',
          '学号': 123456,
          '能力': '电磁炮'}
    
    # a1.setdefault('能力', '肉')
    # a1.setdefault('能力', 'no肉')  # 若键值对存在则不作任何操作,若不存在则添加
    # print(a1)
    
    a1.update(a2)  # 以a2覆盖a1
    print(a1)
    

    • 字典[键] 根据键取值,键值对不存在会报错 。
    • 字典.get(键) 根据键取值,键值对不存在不会报错 。
    • 字典.keys() 可进⾏遍历,获取所有键 。
    • 字典.values() 可进⾏遍历,获取所有值 。
    • 字典.items() 可进⾏遍历,获取所有(键,值)
    a1 = {'name': 'lihua',
          'age': 18,
          'sex': '男',
          '学号': 123456}
    # a2 = {'name': 'zzh',
    #       'age': 16,
    #       'sex': '男',
    #       '学号': 123456,
    #       '能力': '电磁炮'}
    print(a1['name'])  # 若键值对不存在报错
    print(a1.get('nam'))  # 若键值对不存在不报错,返回None
    print(a1.keys())  # 返回所有的键
    print(a1.values())  # 返回所有的值
    print(a1.items())  # 返回所有的键值对
    

    遍历

    • for k in 字典.keys()遍历键
    • for v in 字典.values()遍历值
    • for k, v in 字典.item()遍历键值对
    • for item in 字典.items() 遍历字典的元素(以元组的形式遍历出每一项)
    a1 = {'name': 'lihua',
          'age': 18,
          'sex': '男',
          '学号': 123456}
    for i in a1.items():
        print(i)
    
    
    for k, v in a1.items():
        print(k)
        print(v)
    

    一些方法

    字典.fromkeys(seq, value):
    创建一个字典,seq为新字典的键,value为所有键的默认值,value默认为None

    seq = ('name', 'age', 'sex')
     
    dict = dict.fromkeys(seq)
    print ("新的字典为 : %s" %  str(dict))
     
    dict = dict.fromkeys(seq, 10)
    print ("新的字典为 : %s" %  str(dict))
    

    字符串

    字符串 就是⼀串字符,是编程语⾔中表示⽂本的数据类型,在 Python 中可以使⽤ ⼀对双引号 " 或者 ⼀对单引号 ’ 定义⼀个字符串,字符串是不可变序列,不能直接进行修改等。

    虽然可以使⽤ " 或者 ’ 做字符串的转义,但是在实际开发中:

    如果字符串内部需要使⽤ " ,可以使⽤ ’ 定义字符串
    如果字符串内部需要使⽤ ’ ,可以使⽤ " 定义字符串

    可以使⽤ 索引 获取⼀个字符串中 指定位置的字符,索引计数从 0 开始

    也可以使⽤ for 循环遍历 字符串中每⼀个字符。

    string = "Hello Python"
     
    for c in string:
     
        print(c)
    

    判断

    • string.isalpha() 如果 string ⾄少有⼀个字符并且所有字符都是字⺟则返回 True
    • string.islower() 如果 string 中包含⾄少⼀个区分⼤⼩写的字符,并且所有这些(区分⼤⼩写的)字符都是⼩写,则返回 True
    • string.isupper() 如果 string 中包含⾄少⼀个区分⼤⼩写的字符,并且所有这些(区分⼤⼩写的)字符都是⼤写,则返回 True
    • string.startswith(str) 检查字符串是否是以 str 开头,是则返回 True
      string.endswith(str) 检查字符串是否是以 str 结束,是则返回 True
    • string.istitle()检查所有单词都是首字母大写。
    • string.isspace()检查所有字符都是空的字符。
    • string.isdigit()检查所有的字符都是数字。
    a = '12345667889'
    print(a.isdecimal())
    print(a.isdigit())
    b = 'ahdgkj'
    print(b.isalpha())
    c = 'adg4156'
    print(c.isalnum())  # 判断所有字符都是字母或者数字
    d = ';;;;a'
    f = ';;;;A'
    print(d.islower())
    print(f.isupper())
    

    查找,替换

    1.string.find(str, start=0,end=len(string))
    检测 str 是否包含在 string 中,如果 start 和 end 指定范围,则检查是否包含在指定范围内,如果是返回开始的索引值,否则返回 -1
    2.string.rfind(str, start=0,end=len(string)) 类似于 find(),不过是从右边开始查找
    3.string.index(str, start=0,end=len(string)) 跟 find() ⽅法类似,不过如果 str 不在 string 会报错
    4.string.rindex(str, start=0,end=len(string)) 类似于 index(),不过是从右边开始

    a = '123456789078456'
    x = a.find('7', 0, len(a))  # 找‘7’找到后返回其索引
    y = a.rfind('7', 0, len(a))  # 从右边找
    z = a.rfind('a', 0, len(a))
    print(x)
    print(y)
    print(z)  # 不存在则返回-1
    
    a = '123456789078456'
    x = a.index('7', 0, len(a))  # 找‘7’找到后返回其索引
    y = a.rindex('7', 0, len(a))  # 从右边找
    # z = a.index('a', 0, len(a))
    print(x)
    print(y)
    # print(z)  # 不存在则报错
    

    string.replace(old_str, new_str, num)
    返回⼀个新字符串,把 string 中的 old_str 替换成 new_str,如果 num 指定,则替换不超过 num 次。

    a = '123456789123456789123456789'
    b = a.replace('1', 'a', 2)  # 返回一个改变过的新字符串
    print(a)  # a本身不变
    print(b)
    

    拆分与拼接

    string.split(str="",num)
    返回列表,以 str 为分隔符拆分 string,如果 num 有指定值,则仅分隔 num + 1 个⼦字符串,str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格

    string.splitlines() 返回列表,按照⾏(’\r’, ‘\n’, ‘\r\n’)分隔

    string1 + string2 拼接两个字符串

    string.join(seq) 返回字符串,以 string 作为分隔符,将 seq 中所有的元素(的字符串表示)合并为⼀个新的字符串

    a = 'Hello auidfh\n nadsjk'
    b = ['Hello', 'nihao', 'i love u']
    x = a.split()  # 分割
    y = ','.join(b)
    print(x)
    print(y)
    

    大小写转换

    a = 'aa bb A'
    b = a.title()  # 所有的单词首字母大写
    c = a.capitalize()  # 只有第一个单词首字母大写
    e = a.upper()  # 字符串字符全部大写
    f = a.lower()  # 字符串字符全部小写
    print(b)
    print(c)
    print(e)
    print(f)
    

    文本对齐

    a = 'adff'
    c = a.rjust(10)  # 右对齐,长度填充到10
    d = a.ljust(10)  # 左对齐,长度填充到10
    e = a.center(10)  # 居中,长度填充到10
    print(c)
    print(d)
    print(e)
    
    

    在这里插入图片描述

    去除空白字符

    a = '  adff  '
    c = a.rstrip()  # 去除右边的空格
    d = a.lstrip()  # 去除左边的空格
    e = a.strip()  # 去除两边的空格
    print(c)
    print(d)
    print(e)
    

    提示:列表除了查询⽅法和pop⽅法都没有返回值,字符串所有⽅法都有返回值

    注意!

    
    # 字符串的逆序(⾯试题)
     
    print(num_str[::-1])
    

    Unicode 字符串

    Python 中定义一个 Unicode 字符串和定义一个普通字符串一样简单:

    >>> u'Hello World !'
    u'Hello World !'
    

    引号前小写的"u"表示这里创建的是一个 Unicode 字符串。如果你想加入一个特殊字符,可以使用 Python 的 Unicode-Escape 编码。如下例所示:

    >>> u'Hello\u0020World !'
    u'Hello World !'
    

    被替换的 \u0020 标识表示在给定位置插入编码值为 0x0020 的 Unicode 字符(空格符)。

    三引号(所见即所得)

    python三引号允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符。

    三引号的语法是一对连续的单引号或者双引号(通常都是成对的用)。

    内置方法

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    字符串格式化:

    第一种:%形式
    在这里插入图片描述
    在这里插入图片描述

    name = "周安可"
    age = 18
    sex = "女"
    print("我的名字叫做%s,我的年龄是%d,我的性别是%s"%(name,age,sex))
    
    
    a = 18
    print('%-+10.3f'%a)  # %开始 -左对齐 +对正数加+ 10最小宽度 .3小数点精度 f指定的转换类型
    

    第二种format

    a = '{}喜欢{}!'
    b = '{0}喜欢{1}!'
    c = '{name1}喜欢{name2}!'
    print(a.format('周安可','李淳风'))
    print(b.format('周安可','李淳风'))
    print(c.format(name1='周安可',name2='李淳风'))
    

    在这里插入图片描述
    在这里插入图片描述

    字符串常量:

    import string
    
    print(string.ascii_lowercase)  # 小写字符
    print(string.ascii_uppercase)  # 大写字符
    print(string.ascii_letters)  # 大小写字符
    print(string.digits)  # 数字
    print(string.whitespace)  # 空白字符
    print(string.punctuation)  # 标点符号
    print(string.printable)  # 可打印字符串的字符,包括大小写字符,标点,空白符
    print(string.hexdigits)  # '0123456789abcdefABCDEF'
    print(string.octdigits)  # '01234567'
    
    

    pypinyin库与jieba库

    在这里插入图片描述
    在这里插入图片描述

    集合:

    集合创建
    a={1,2}
    a=set()
    集合中的元素只能是可哈希的(即不可变类型)。

    集合元素的增加
    add()方法可以增加新元素,如果该元素已存在则忽略该操作,不会抛出异常;
    update()方法用于合并另外一个集合中的元素到当前集合中,并自动去除重复元素。

    集合元素删除
    pop()方法用于随机删除并返回集合中的一个元素,如果集合为空则抛出异常;
    remove()方法用于删除集合中的元素,如果指定元素不存在则抛出异常;
    discard()用于从集合中删除一个特定元素,如果元素不在集合中则忽略该操作;
    clear()方法清空集合删除所有元素。

    集合运算

    a_set = set([8, 9, 10, 11, 12, 13])
    b_set = {0, 1, 2, 3, 7, 8}
    a_set | b_set #并集
    {0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
    a_set.union(b_set) #并集
    {0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
    a_set & b_set #交集
    {8}
    a_set.intersection(b_set) #交集
    {8}
    a_set.difference(b_set) # 差集
    {9, 10, 11, 12, 13}
    a_set - b_set
    {9, 10, 11, 12, 13}
    a_set.symmetric_difference(b_set) #对称差集
    {0, 1, 2, 3, 7, 9, 10, 11, 12, 13}
    a_set ^ b_set
    {0, 1, 2, 3, 7, 9, 10, 11, 12, 13}

    好累好累!终于集合好了。实际上最后的图片有大多数方法都不常用。作者觉得把作者前面分类的方法熟悉就足够用了。

    希望能帮到大家。

    展开全文
  • 字符串转换为列表 使用list()方法 str_1 = 1235 str_2 = 'zhangsan' str_3 = '''lisi''' tuple_1 = list(str_1) tuple_2 = list(str_2) tuple_3 = list(str_3) print(type(tuple_1)) print(type(tuple_2)) print...
  • 主要介绍了Python 字符串列表元组的截取与切片操作,结合实例形式分析了Python针对字符串列表元组的截取与切片相关操作技巧,需要的朋友可以参考下
  • 目录 数组——集装箱:只放一种...列表元组字符串——序列的共同点 数组——集装箱:只放一种类型 列表——工厂仓库:可以放很多类型(1.普通 2.混合 3.空列表) 增加元素:append(),extend() ,insert() ...
  • python列表元组字符串 python中列表元组字符串均为可迭代对象: lst = [1,2,3,4] for i in lst:print(i,end=' ') print() tu = (1,2,3,4) for i in tu:print(i,end=' ') print() str = '1234' for ...
  • 列表元组字符串之间的共同点

    千次阅读 2018-08-11 17:00:28
    所以把列表元组字符串三者统称为序列 序列有一些BIF(内置函数) 如:list(),作用是:把一个可迭代对象转换为列表 a =list() 生成一个空列表[ ] b = ’ I love you’ b是一个字符串 b = list(b) ...
  • 一、列表元组字符串的共同点 1.都可以通过索引得到每一个元素 2.默认索引值总是从0开始 3.可以通过分片的方法得到一个范围内的元素的集合 4有很多共同的操作符(重复、拼接、成员关系操作符) 二、列表元组和...
  • 最近学习做的习题,直接复制过来 缩进就乱掉了,所以直接以图片方式上传,题目和答案一起 转载于:https://www.cnblogs.com/sunyucui/p/5685675.html
  • I've written a function in python that returns a list, for example[(1,1),(2,2),(3,3)]But i want the output as a string so i can replace the comma with another char so the output would be'1@1' '2@2' '3...
  • 字符串列表元组总结 类型 字符串 列表 元组 增 拼接用+号 Append()extend()insert() 不能 删 strip删除指定字符rstrip从右开始删除指定字符lstrip从左开始删除指定字符 Pop()remove()删除第一次遇到的...
  • 列表元组字符串

    2020-07-28 21:09:00
    ·Python 的元组列表类似,不同之处在于tuple被创建后就不能对其进行修改,类似字符串。 ·元组使用小括号,列表使用方括号。 ·元组列表类似,也用整数来对它进行索引 (indexing) 和切片 (slicing)。 创建元组...
  • Python中共有68种内置序列(有些内置函数也能返回一些特殊序列,可以对它进行一些通用的序列操作),其中有三种比较常见:列表元组字符串 Python中大部分序列都可以进行通用操作,包括索引,切片,相同类型序列...
  • 字符串列表元组总结

    2019-07-18 21:32:02
    字符串 列表 元组 定义空元素的方法 " " 或者 str ( ) [ ] 或者 list ( ) ( ) 或者 tuple( ) 可变类型 可变 可变 不可变 数据类型 有序 有序 有序 可否重复 可以 可以 可以 ...
  • Python字符串列表元组练习题

    千次阅读 2020-03-23 10:37:18
    Python字符串列表元组练习题 1、接收输入的一行字符,统计出字符串中包含数字的个数。 myStr = input("请输入任意字符串:") num = 0 for s in myStr: if s.isdigit(): num += 1 print(num) 2、请输入星期几的...
  • 码字不易,转载请标明出处… ... list_ = [] # 定义一个空列表,用来存储判断后的数据 for i in range(len(seq) - 1): # 假如 len(seq) = 17 , 则range(16) --&gt; 0-16 if seq[i] != seq[...
  • 元组列表区别元组列表类似,但其元素是不可变,即元祖一旦创建,用任何方法都不可以修改其元素,元组相当于只读列表。 相同点:\ 元组的元素与列表一样按定义的次序进行排序。 元组的负数索引与列表一样,...
  • 字符串列表元组这三个统称为序列(sequence),三者有很多共性,也有自己的特性,本文先介绍如何新建,如何访问,以及如何更新来介绍序列,最后来说明列表元组区别 一、如何新建序列并赋值 1astring = ...
  • 字符串列表元组均可通过“+”号进行拼接,但要求同种类型数据之间才能拼接 #字符串拼接 a = "Hello" b = ",Python" print(a + b) #列表拼接 li1 = ["I"] li2 = ["Love","Python"] print(li1 + li2) ...
  • Python 元组字符串列表

    千次阅读 2020-03-17 19:16:08
    1.单一字符串型元祖转字符串 t1 = ('a','b','c','d','e') s1 = "_".join(t1) print('t1:',t1) print('s1:',s1) ...2.混合数据类型元组字符串 t1 = ('a','b',1,2,'e') s1 = '_'.join(map(str, t1...
  • 文章目录列表字符串、字典、元组之间的转换1. 列表字符串的相互转换列表字符串字符串列表2. 列表与字典的相互转换列表转字典两个列表转字典嵌套列表转字典字典转列表3. 字典与字符串的相互转换字符串转字典...
  • 共用方法: + * in ...字符串:①下标与切片 ② 常用方法 列表:①下标与切片 ② 循环遍历 ③ 常用方法 元组:①创建元组元组的方法 字典:①字典格式 key-value②字典常用方法 ③字典遍历 ...
  • 1、字符串:属于序列类型、有下标(且唯一) 可以进行切片操作,不能改变值。 str1='helloworld' #取前半段,左边包含右边不包含 print(str1[:5]) #取后半段 print(str1[5:]) #取倒序 print(str1[::-1]) 2、列表:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 177,399
精华内容 70,959
关键字:

列表元组字符串的区别