精华内容
下载资源
问答
  • >>> set = {'a', 'b', 'c'} >>> set set(['a', 'c', 'b']) >>> ''.join(set) 'acb' 参考文献: 1. 暂缺。
    >>> set = {'a', 'b', 'c'}
    >>> set
    set(['a', 'c', 'b'])
    >>> ''.join(set)
    'acb'

    参考文献:
    1. 暂缺。

    展开全文
  • 字符串 概念:字符串里面存储 字符类型 的 不可变的 序列 容器 1.转义字符 1.1.什么是转义符 \就是转义符,转义符可以将有意义的字符成无意义的字符. \可以将无意义的字符转换为有意义的字符 \n: 代码换行 \t: 代表...

    字符串

    概念:字符串里面存储 字符类型 的 不可变的 序列 容器

    1.转义字符

    1.1.什么是转义符
    \就是转义符,转义符可以将有意义的字符转成无意义的字符.
    \可以将无意义的字符转换为有意义的字符
    \n: 代码换行
    \t: 代表制表符(tab键)
    \: 代表\字符

    1.2.特殊用法:
    单引号和双引号在字符串中的注意事项:
    1.在计算机的编程语言中: 单双引号必须交替使用,否则必须语法就会出错
    2.如果字符串中出现了相同的引号必须通过转移字符转移称为一个普通的引号
    3.在单双引号交替使用的情况下,转移符号\无意义
    4.在很多语言中使用""定义字符串,在Python中都一样

    1.3.访问字符
    语法:
    字符 = 字符串[索引]

    1.4.while遍历字符
    语法:
    索引= 0;
    长度 = len(字符串)
    while 索引 < 长度:
    元素 = 字符串[索引]
    索引+=1

    1.5.for in 专业遍历
    语法:
    for 字符 in 字符串:
    print(字符)

    2.字符串的常见操作

    2.1.去除左右两边空格
    语法:
    string.strip() 去除两边的空格
    string.lstrip() 去除左边的空格 l==>left(左)
    string.rstrip() 去除右边的空格 r==>right(右)
    string.strip(“要去除的字符”) 去除指定字符

    2.2.字符串分割
    语法:
    string.split() 按照空格字符串分割,返回一个列表
    string.split(‘分隔符’) 按照分隔符分割,返回一个列表
    string.split(‘分隔符’,分割次数) 按指定次数照分隔符分割,返回一个列表
    string.rsplit(‘分隔符’,分割次数) 从后面开始按指定次数照分隔符分割,返回一个列表

    2.3.大小写转换
    语法:
    string.lower() 转换为小写
    string.upper() 转换为大写

    2.4.判断开头和结尾的字符
    语法:
    string.startswith(‘开头字符’)
    string.endswith(‘结尾字符’)
    返回值为一个布尔值,判断是否字符串的开头或者结尾为指定字符

    2.5字符串格式化函数
    语法:
    “需要格式化的字符”%(数据1,数据2)
    f"字符{变量}串"
    string.format(“数据1”,“数据2”,“数据3”)
    print(‘我的名字是{},我的年纪{}’.format(‘小强’,29))
    print(‘我的名字是{0},年纪{1}’.format(‘小强’,29))
    print(‘我的名字是{name},年纪{age}’.format(name=‘小强’,age=18))

    2.6.字符串连接
    语法:
    自定义连接符.join[列表]
    用自定义连接符将列表中的元素连接起来

    2.7.字符串替换
    语法:
    string.replace(‘原文’,‘新文’)
    将字符串中的原文替换成 替换的文字

    2.8.判断字符串由数字组成
    语法:
    string.isdigit()
    返回值是一个布尔值,小数事False

    3.字典

    概念:字典(dictionary)同样是容器,只不过字典中的数据以映射关系来维护,这种映射关系k -> v,我们称k为键,v为值。

    语法:
    字典={‘key1’:'值1,‘key2’:‘值2’,‘key3’:‘值3’,‘keyn’:‘值n’}

    3.1.字典-修改
    3.1.1.添加或者修改
    语法:
    字典 [key]=(value)
    如果key不存在,添加键值对.
    如果key存在,修改value。

    3.1.2.添加或者返回原值
    values=字典.setdefault(key,value)
    如果key不存在,添加键值对。
    如果key存在,不修改value,但返回原来value

    3.1.3.合并
    字典.update(字典2)
    将字典2的数据合并到字典,字典2会覆盖字典中已存在的内容.

    3.2.字典-删除
    3.2.1.删除键值对
    del 字典[key]
    字典.pop(key)
    删除指定键值对,如果key不存在,就报错

    3.2.2.清空内容
    语法:
    字典.clear()
    清空字典所有键值对,删除成功后,查询,返回{ }

    3.3.字典-查询
    3.3.1.根据key查询value
    语法:
    字典[key] 根据key查询值,如果key不存在,就报错
    字典.get(key) 根据key查询值,如果key不存在,返回None

    3.3.2.获取键值对数量
    语法:
    len(字典)

    3.3.3.获取字典中的所有值
    语法:
    字典.values()
    将获取的值,先转换成列表类型,再按照索引进行查询

    3.3.4.获取字典中所有的键
    语法:
    字典.keys()

    3.3.5.判断键是否在字典中存在
    语法:
    key in 字典
    返回的是一个布尔类型的值

    3.4遍历
    3.4.1.遍历key
    语法:
    for 临时变量 in 字典:
    print(临时变量)

    3.4.2.遍历value
    语法:
    for 临时变量 in 字典.values():
    print(临时变量)

    3.4.3.遍历键值对
    语法:
    for 临时变量 in 字典.items():
    print(临时变量)

    3.4.4.遍历键和值
    语法:
    for 临时变量key,临时变量value in 字典.items():
    print(临时变量key,临时变量value)

    4.集合

    4.1.概念:集合(set)是一个无序的不重复元素序列(容器).
    可以使用大括号 { } 或者 set() 函数创建集合.
    注意:创建一个空集合必须用 set() ,而不是 { },因为 { } 是用来创建一个空字典。
    主要作用:去重

    4.2.创建语法:
    param = {value01,value02,…}
    或者
    set() 创建一个空集合

    4.3.其他类型转换为集合
    语法:
    变量名 = set(字符串的数据|列表的数据|字典的数据)

    5.公共语法

    5.1.Python 内置函数
    支持类型: 字符串、列表、元组、字典、集合
    len () 计算容器中的元素个数
    del () 删除变量
    max() 返回容器中的元素最大值
    min() 返回容器中的元素最小值
    注意:max和min一般用于数字比较,字符较少,如果进行比较,按照ascii码值对比.
    max,min在字典中是按键的字符比较

    5.2.切片
    语法:
    [开始:结束:步长]
    支持类型: 字符串,列表,元组。不支持字典

    5.3.运算符
    +:合并,支持类型:字符串,列表,元组
    *:重复,支持类型:字符串,列表,元组
    in:元素是否存在,支持类型:字符串,列表,元组,字典,返回布尔值
    not in:元素是否不存在,支持类型:字符串,列表,元组,字典,返回布尔值

    5.4.专业遍历,for in:
    语法:
    for 变量 in 集合:
    循环体代码
    else:
    只要没有通过 break 退出循环,都会执⾏的代码
    支持类型: 字符串,列表,元组,字典

    展开全文
  • 本文主要介绍列表,元组,字典,集合以及和字符串之间的相互转换。 \1. 列表与元组的互换 # 将列表转化为元组 li = [1, 2, 3] t = tuple(li) print(t, type(t)) # 打印结果:(1, 2, 3) <class 'tuple'> # 将...

    img

    本文主要介绍列表,元组,字典,集合以及和字符串之间的相互转换。

    \1. 列表与元组的互换

    # 将列表转化为元组
    li = [1, 2, 3]
    t = tuple(li)
    print(t, type(t))
    # 打印结果:(1, 2, 3) <class 'tuple'>
    
    # 将元组转换成列表
    tu = (1, 2, 3)
    li = list(tu)
    print(li, type(li))
    # 打印结果:[1, 2, 3] <class 'list'>
    

    \2. 列表与字符串的互换

    # 列表转换成字符串
    li = ['人', '生', '苦', '短']
    str1 = ''.join(li)
    print(str1, type(str1))
    # 输出结果:人生苦短 <class 'str'>
    
    # 字符串转换成列表
    str2 = 'hello python'
    li1 = str2.split(' ')
    print(li1, type(li1))
    # 输出结果:['hello', 'python'] <class 'list'>
    

    \3. 列表与字典转换

    # 列表转字典方式一
    list1 = ['name', 'age', 'sex']
    list2 = ['张三', 18, '男']
    dict = {}
    for i in range(len(list1)):
        dict[list1[i]] = list2[i]
    print(dict, type(dict))
    # 输出结果:{'name': '张三', 'age': 18, 'sex': '男'} <class 'dict'>
    
    # 列表转字典方式二:使用内置函数zip
    list1 = ['name', 'age', 'sex']
    list2 = ['张三', 18, '男']
    d = dict(zip(list1, list2))
    print(d)
    
    # 字典转换成列表
    dict = {'name': '张三', 'age': 18, 'sex': '男'}
    keys = list(dict.keys())
    values = list(dict.values())
    print(keys, type(keys))
    print(values, type(values))
    

    4.嵌套列表转字典

    list3 = [['key1','value1'],['key2','value2'],['key3','value3']]
    print(dict(list3))
    

    \5. 列表与集合转换

    # 列表转集合
    list1 = [1, 3, 4, 3, 2, 1]
    s1 = set(list1)
    print(s1, type(s1))
    # 输出结果:{1, 2, 3, 4} <class 'set'>
    
    # 集合转列表
    list2 = list(s1.intersection(s1))
    print(list2, type(list2))
    # 输出结果:[1, 2, 3, 4] <class 'list'>
    

    \6. 元组和字符串转换

    # 元组转换成字符串和列表方法一样
    
    # 字符串转换成元组,需要将字符串转换成列表,在利用列表转成元组
    list = []
    a = '人生苦短'
    list.append(a)
    print(list)
    b = tuple(list)
    print(b, type(b))
    # 输出结果:('人生苦短',) <class 'tuple'>
    

    7.元组和字典转换

    # 字典转元组
    dict = {'name': 'xiaoming', 'age': 18}
    tup = tuple(dict)
    print(tup)  # 只转换了key
    
    tup2 = tuple(dict.values())
    print(tup2)
    
    # 元组不能转成字典
    

    8.字典和字符串转换

    # 字典转换为字符串
    dic1 = {'a': 1, 'b': 2}
    str1 = str(dic1)
    # 输出结果:{'a': 1, 'b': 2} <class 'str'>
    
    # 字符串转字典
    dic2 = eval("{'name':'xiaoming', 'age':18}")
    print(dic2, type(dic2))
    

    9.字符串和集合转换

    # 字符串转集合
    str1 = 'hello'
    s1 = set(str1)
    print(s1, type(s1))
    # 输出结果:{'e', 'o', 'h', 'l'} <class 'set'>
    

    10.字典key和value值转换

    dic1 = {'a': 1, 'b': 2, 'c': 3}
    dic2 = {value: key for key, value in dic1.items()}
    print(dic2)
    
    展开全文
  • 一、字符串 (一)字符串的介绍 简单的字符串:双引号或者单引号之间的数据,就是字符串 print("Let's go") print("Let\'s go") # \'用来意 原始字符串: str1 = "C:\naaa\nbbb\...

    一、字符串

    (一)字符串的介绍

    • 简单的字符串:双引号或者单引号之间的数据,就是字符串
    print("Let's go")
    print("Let\'s go")   # \'用来转意
    • 原始字符串:
    str1 = "C:\naaa\nbbb\nccc"
    print(str1)      # 想打印出目录,\n默认为换行
    str1 = r"C:\naaa\nbbb\nccc"
    print(str1)      # 前面加一个R能起到打印字符串的作用  

    (二)字符串的下标索引和切片

    • 字符串索引、替换
    str1 = "abcdef"
    print(str1[0])   #打印出第一个字符
    print(str1[2])
    # 将字符串中的'a'改为0
    str1[0] = "0"    #不能直接用下表替换,会报错。
    print(str1)
    # 只能用replace替换,replace(str1,str2)将字符类型的str2替换成str1
    print(str1.replace("a","0"))
    print(str1)      #原字符串不变
    • 符串的切片
    str1 = '1234567890'
    # 截取字符串最后三位的字符
    print(str1[7:])
    print(str1[-3:])     #为设定步进的时候,步进默认为1,从左往右
    # 截取字符串的全部字符
    print(str1[:])F
    # 截取字符串的倒数第一个字符
    print(str1[-1])
    # 截取与原字符串顺序相反的字符串
    print(str1[::-1])         #快速将字符串逆置
    # 截取字符串倒数第三位与倒数第一位之前的字符
    print(str1[-3:-1])
    # 截取086。
    print(str1[:4:-2])
    当[a:b:c]   当a决定C  

    (三)字符串的查找与检查(find(), index(),count())

    str1 = "you are my firends"
    # find() 检查字符串是否包含在str1中,如果在返回开始索引值,否则返回-1
    print(str1.find("are"))            # a = 4   返回值需要赋给变量名
    # index() 和find()一样,只不过会报错
    # count(str,start,end) 返回字符串在开始和结尾之间在st1中出现的次数
    print(str1.count("e"))    #如果没设置开始和结尾则默认真个字符串中
    print(str1.count("e",7,12)) #如果去掉12则默认为7到字符串末端
    # rfind()      #从右边开始查找,在查找文件的后缀时可以用
    # rindex()   #从右边开始索引

    (四)字符串的判断

    str1 = "we are friends"
    # isalpha() 如果str1中所有字符都是字母,返回True
    print(str1.isalpha())       #False  因为有空格
    # isdigit() 如果str1中所有字符都是数字,返回True
    # isalnum() 如果str1中所有字符是数字或者字母,返回True
    # isspace() 如果str1中所有字符都是空格,返回True
    # startswith(we) 检查we是否在字符串str1中以开头出现,返回bool
    # endswith(friends) 检查friends是否在字符串str1中以结尾出现,返回bool

    (五)字符串修改

    str1 = "we are friends"
    # split(str,a) 以str为分隔符切片str1,如果a有指定值,则仅分割a个子字符串
    # splitlines()  按照行分隔符,返回一个包含各元素的列表
    # capitalize() 把t字符串第一个字符大写
    # title()  把字符串的每个单词首字母大写"We Are Friends"
    # lower()  把所有字符串的大写字符小写
    # upper()  把字符串所有小写字母大写
    # ljust(width)  返回一个原字符串左对齐,使用空格填充至长度width的新字符串
    # rjust(width)  返回一个原字符串右对齐,使用空格填充至长度width的新字符串
    # center(width) 返回一个原字符串居中,并使用空格填充至长度width的新字符串
    # lstrip()  删除str1左边的空格
    # rstrip()  删除str1右边的空格
    # strip()  删除str1两端的空格
    # partition(str)  将str1分割成为前中后三部分
    # rpartition(str)  从右开始将str1分割成为前中后三部分
    # join(list)    str1每个元素后面插入str2构造成一个新的字符串
    str2 = "_"    将列表中的字符串一“ ”方式写成新的字符串
    print(str2.join(str1))
    •  

    二、列表

    (一)列表的特点和创建

    1、可以对不同类型数据储存,但是要避免储存多种数据类型 
    list1 = [1,2,”曹哲”,(1,2,3,4)] list1 = [] 
    2、和str一样可以索引和切片 
    索引出list1中的4:list1[3][3] 
    3、迭代。for i in list1:: 
    print(i) 
    4、renge(10) 
    5、列表和普通变量的区别:列表是数据类型,普通列表是用来存储数据的,可以把列表复制给普通变量。 
    6、列表的缺点:①在头部或者其他部分添加元素,效率比较低。 
    ②根据某个特征查找元素,效率非常低。 
    字典能满足他!!! 
    7、列表不能作为字典和集合的元素。。。

    (二)列表添加元素

    list1 = [1,2,3,4]
    #### insert(index,object)  在指定位置index前插入元素object.
    list1.insert(2,5)
    #### 列表是可变的,所以插入后还是返回原列表
    print(list1)
    ## append() 再末尾追加一个任何类型的数据
    list1.append([1,2,3,4])
    print(list1)
    ## extend()  在列表末尾追加数据,如果是列表或元祖,拆分后将追加到列表里
    list1.extend((6,7))  # extend()中的元素必须为可迭代对象
    print(list1)

    (三)列表修改和删除元素

    list1 = [1,2,3,4,[5,6,7],8]
    # 修改,根据元素下标直接赋新值,如果不知道下标,用index()索引获得
    list1[4][2] = 0         #打印list1
    list1[list1.index(4)] = 10               #打印list1
    # remove()  删除列表内指定的数据  
    list1.remove(2)         #打印list1
    # pop()  删除列表中指定的下标的数据,并返回该数据,(如果没有参数,则默认最后的数据)
    print(list1.pop())      #打印list1
    # clear() 清除列表所有数据,但不删除列表。
    list1.clear()           # 打印list1
    # del Python提供的删除方式,可以删除任何数据
    del list1

    (四)查找列表元素

    list1 = [1,2,3,4,[5,6,7],8]
    # in 和 not in 判断元素是否存在列表,字符串,元组里
    # index(元素,开始,结束)  返回列表里指定元素的下标(如果没有,报错)
    print(list1.index(3,1,4))
    # count(元素,开始,结束)  返回列表里指定元素个数

    (五)列表排序和倒置

    list1 = [1,3,2,4,0]
    # sort()  Python列表提供的方法,在原列表上排序,Python2支持混合列表排序,3只支持统一类型排序
    list1.sort()         #打印list1
    # sorted()  BIF Python提供的方法,返回新列表,原列表不变
    print(sorted(list1))
    # reverse()  将列表倒置。
    list1.reverse()        #打印list1
    # sorted(list1,reverse = True)     #返回一个新的列表
    print(sorted(list1,reverse = True))
    list2 = list(reversed(sorted(list1)))

    (六)列表的拷贝

    list1 = [1,3,2,4,0]
    # 引用  (浅拷贝):只是增加了一个原数据的引用,地址不变
    list2 = list1                 #他们的地址一样。
    if id(list2) == id(list1):    #若改变list2,也改变list1。没有真正实现拷贝
        print("浅拷贝")
    # copy()深拷贝  拷贝一个分数据给新列表,和原列表没有任何关系
    list2 = list1.copy()    #打印list2
    # 用切片的方式复制(相当于copy.deepcopy())
    list2 = list1[:]

    (七)列表推倒式

    # 将一段代码写成推倒式
    list2 = []
    for i in range(1,21):
        if i % 2 == 0:
            list2.append(i)
    print(list2)
    # 在表达式中for遍历一般与if一起用
    # 先执行for 循环。
    list1 = [i for i in range(1,21) if i % 2 == 0]
    print(list1)
    # 如果返回值和没有遍历值:生成10个“666”的列表
    # list3 = ["666" for i in range(0,10)]
    # i 只是起到遍历,没有起到判断值或者返回值的作用,可以用下划线代替
    list3 = ["666" for _ in range(0,10)]
    print(list3)

    (八)列表的常用技巧

    • 列表合并:
    list1 = [1,2,3,4]
    list2 = [5,6,7,8]
    # 返回一个新列表list3
    list3 = list1 + list2    #print(list3)
    # 如果是用list1 += list2 在原列表追加,不生成新列表(列表可变)
    list1 += list2           #print(list1)
    • 将字符串转列表:
    mystr = "we are friends"
    # 可以用split()先将mystr分割成三个字符串的列表
    print(mystr.split(" "))
    # 如果直接用list强制转换,则会使得每一个字符成为一个列表元素
    print(list(mystr))
    • 将列表转为字符串:
    list1 = ['we', 'are', 'friends']
    # " ".join()    把谁谁谁加入到(list)
    print(" ".join(list1))   #只能转列表的每一个元素都为字符串
    list2 = [10,20,30]
    # 那么如何将list2转为字符串?
    # 首先应该先将list2中的每个元素转为字符型,返回成列表,再进行转化
    print(" ".join([str(i) for i in list2]))
    • 内置函数(BIF):
    list1 = [10,20,30,40]
    # isinstance()  内置函数,判断对象是否为指定类型,返回True
    if isinstance(list1,list):
        print("list1是列表")
    if isinstance(list1[1],int):
        print("列表中第二个元素是整形")
    # enumerate(列表,元祖,字符串等)   获取列表的元素下标和元素,返回一个列表
    list(enumerate(list1)) 
    for x,y in enumerate(list1):
        print(x,y) 

    (九)列表的嵌套及应用

    # 一个学校,有3个办公室,现在有8位老师等待工位的分配,请编写程序,完成随机的分配
    import random;
    offices = [[],[],[]]          #   三个办公室
    names = ["A","B","C","D","E","F","G","H"]     
    # 8位老师
    # 现在我们要定一个教室的随机分配,一次提取names中的元素放入到教室里
    for name in names:
        index = random.randint(0,2)
        offices[index].append(name)
    i = 1
    for tempName in offices:
        print("第%d个教室有%d名老师。"%(i,len(tempName)))
        i += 1

    三、元组

    (一)元组的特点

       **元祖不可以更改,用(,)表示**
    

    (二)元祖的创建、查询与统计

    # range()  创建元组
    a = tuple(range(10,20,2))
    print(a)
    # 读取元组下标,找到元组元素
    print(a[1])
    # index() 返回值指定元素的下标(如果没有,报错)
    print(a.index(12))
    # count() 统计指定元素个数
    print(a.count(12))

    四、字典

    (一)字典的基本使用

     字典查找要比列表速度快,字典和元素个数没关系。    
    # ①设计字典,键一般用字符串表示。
    #   字典是由键值对和花括号组成
    #   字典的每个元素由2部分组成,键:值。
    #   字典没有牵引,不能通过下标取值,只能通过键名来取值
    num_dict = {"name":"python","age":36,"id":10}
    print(num_dict["name"])
    
    # ②创建字典
    num_dict = {}
    a = num_dict.fromkeys("abcd",10)
    ####{'a': 10, 'b': 10, 'c': 10, 'd': 10}
    
    # ③长度
    print(len(a))   #   4 

    (二)字典修改元素和数据添加

    # ①根据键名修改元素
    name_dict = {}
    name_dict["name"] = "python"  #如果字典里没有键,则创建这对键值
    print(name_dict)              #{'name': 'python'}
    name_dict["name"] = "lihua"   #如果字典里有这个键,改变这个键的值
    print(name_dict)              #{'name': 'lihua'}
    
    # ②setdefault()
    name_dict = {"name":2}
    name_dict.setdefault("name")  #如果键不在字典里,则返回默认值NONE,并创建
    print(name_dict)              #{'name': None}
    name_dict.setdefault("name",1)  #如果键不在字典里,则返回默认值1,并创建这对键值
    print(name_dict)                #{'name': 1}
    print(name_dict.setdefault("name")) #如果键在字典里,则返回值Value
    
    # get() 和setdefault基本一样。不同的是get()不会添加键值对
    info = {'name': '班长', 'id': 100, 'sex': 'f'}
    print(info.get("tess"))      #如果没有这个键,则返回None
    print(info)                  #没有将返回的键值添加到info里
    # ③keys()  返回这个字典所有键的列表
    info = {'name': '班长', 'id': 100, 'sex': 'f'}
    print(info.keys())        # dict_keys(['name', 'id', 'sex'])
    
    # ④values()  返回这个字典所有值的列表
    print(info.values())      # dict_values(['班长', 100, 'f'])
    
    # ⑤items()   返回这个字典所有键值对(元祖)的列表
    print(info.items())       #dict_items([('name', '班长'), ('id', 100), ('sex', 'f')])

    (三)字典拷贝,更新与删除

    # ①copy()   拷贝
    info = {'name': '班长', 'id': 100, 'sex': 'f'}   #对象id发生变化
    print(info.copy())        #   {'name': '班长', 'id': 100, 'sex': 'f'}
    
    # update()  字典更新,替换成新增
    info_dict = {"name":"python","age":14}
    new_info_dict = {"name":"hello","id":123,"age":1233}
    info_dict.update(new_info_dict)     # 跟新new_info_dict到info_dict..
    print(info_dict)
    
    # ②pop() 参数是键,删除指定的键值对,并返回值
    print(info.pop("name"))    # 班长
    print(info.pop("sss"))     # 报错
    
    # ③popitem() 依次从后向前删除键值对,并返回这个键值对的元组
    print(info.popitem())         # 删除的返回值('sex', 'f')
    
    # ④clear() 清空字典
    # ⑤del(info)  删除字典

    (四)字典推导式

    # # 类似于列表,只是用花括号,返回的参数为键值对。
    new_dict = {i : i**2 for i in range(1,5)}
    print(new_dict)        #  {1: 1, 2: 4, 3: 9, 4: 16}
    
    # # 将两个列表合并为字典
    list1 = ["name","age","id"]
          list2 = [4,5,6]     #怎么拿出"name"
    new_dict = {list1[i]:list2[i] for i in range(len(list1))}
    print(new_dict)     #{'name': 4, 'age': 5, 'id': 6}
    
    # # 将一个字典转换为列表。
    new_dict = {"name":"python","old":1}
    list1 = []
          for key in new_dict.keys():
         list1.append(key)
    for value in new_dict.values():
         list1.append(value)
    
    # 字典键值对互相转换
    new_dict = {"name":"python","old":1}
    print({value : key for key,value in new_dict.items()})

    (五)字典补充

    在python2中dict.has_key(key)用来判断dict中是否存在键key(python2中)。返回True。 
    python2中 dict.keys或者dict.items,dict.values 返回的是列表。而python3返回的是dict_keys([‘yellow’, ‘red’, ‘green’])

    五、集合

    (一)集合的创建和特点

    # ①集合、列表、元组可以互相转换
    # ②集合中的数据都是唯一的,去重的最快方式是集合
    new_set = {1,2,3,4,3,2,4,5}
    print(new_set)      #{1, 2, 3, 4, 5}   自动排重
    # ③如果需要,一般集合会转列表做复杂的操作,再转为集合
    # ④创建一个空集合
    new_set = set()

    (二)集合添加数据,删除数据

    # add()  向集合里添加一个元素
    new_set = {1,2,3,4,5}
    new_set.add(6)
    #####字典结合都是无序的,不能索引,集合本身不能排序,如果想排序需转成列表方式
    
    # update()  向集合中添加多个数据,参数是一个列表
    new_set = {1,2,3,4,5}
    new_set.update([1,2,5,6])    #{1, 2, 3, 4, 5, 6}
    
    # remove() 删除指定的数据,数据不存在则把报错
    # discard() 本意有抛弃的意思 删除指定数据,数据不存在则不做任何操作
    #  pop()   无参数默认,则从前往后依次摘除
    new_set = {1,2,3,4,5}
    print(new_set.pop())

    (三)集合的数学运算

    #  交集
    a = {1,2,3,4}
    b = {2,3,4,5}
    print(a & b)       #  {2, 3, 4}
    
    # 并集
    print(a | b)       #  {1, 2, 3, 4, 5}
    
    # 差集
    print(a - b)       # a - b  剩下a有b没的  {1}
    print(b - a)       # b - a  剩下b有a没的  {5}
    
    # 对称差集
    print(b ^ a)       #  {1, 5}
    
    # b是否是a的子集
    b <= a
    
    # a是否是b的子集
    b >= a
    
    # 优先级
    差集 > 交集 > 并集
    展开全文
  • python学习-字符串

    2019-09-29 07:09:16
    str 字符串 list 列表 tuple 元组 .dict 字典  set 集合 二、int 类型的操作  bit_length() 返回二进制长度 三、bool 类型 类型转化: 想什么就用什么括起来  当成FALSE:所有的空都是False,...
  • 一、字符串 (一)字符串的介绍 简单的字符串:双引号或者单引号之间的数据,就是字符串 print("Let's go") print("Let\'s go") # \'用来意 原始字符串: str1 = "C:\...
  • Python(字符串、字典和集合) 一、字符串     1.什么是字符串         (1)字符串或串(String)是由数字、字母、下划线、组成的一串字符。它是编程语言中表示文本的数据类型。使用单引号、双引号和三引号...
  • 1.字符串 字符串内置方法 方法 作用 index 从左到右找字符,没找到报错 find 从左到右找字符,没找到返回 -1 rindex 从右到左找字符,没找到报错 rfind 从右到左找字符,没找到返回 -1 replace 用...
  • 字符串 1.str方法及注释 2.格式化字符串 二 序列(列表、元组、字符串) 1.list()把一个可迭代对象转换成(每一个字符单独的)列表 2.tuple([iterable])把一个可迭代对象转换成元组 3.str(obj)把obj对象...
  • python字符串字典集合

    2019-12-25 11:17:56
    1.什么是转义符:\就是转义符,转义符可以将有意义的字符成无意义的字符. 也可以将无意义的字符转换为有意义的字符 ...2.2取出部分字符(切片):字符串=字符串[开始:结束:步长] 步长也可以是负数:为负数时倒序...
  • 文章目录字典字典元素的获取字典生成式元组元组的创建方式集合集合的创建方式集合的操作集合间的关系集合生成式字符串字符串查询操作字符串大小写转换字符串内容对齐操作字符串劈分操作判断字符串的方法字符串的替换...
  • Python 字符串

    2019-09-29 00:57:21
    版权所有,未经许可,禁止转载 章节Python 介绍 Python 开发环境搭建 ...Python 字符串(String) Python 运算符 Python 列表(list) Python 元组(Tuple) Python 集合(Set) Python 字典(Dictionary) Python If...
  • 首先看如下代码: a = ['0234','abcd'] seta = set(a) b = ['0234'] setb = set(b) ...总之,想要找出这种细微差别的原因,可能只有去查看Python的底层C++源码是怎么定义字符串、列表、元组、集合的了
  • 1、列表元祖字典集合 列表 list = ["a", "b", "c", "d"] 元祖 tup = (1, 2, 3, 4, 5 ) 1、元组与列表类似,不同之处在于元组的元素不能修改,不允许删除 2、可以使用list() 和 tuple()方法相互转换 列表和元祖...
  • 字符串相关操作大致总结以下9个部分,包括常用字符集合、大小写转换、判断字符元素类型、字符填充、字符串搜索、字符串替换、字符串添加、字符串修剪以及字符串分割。"字符串相关函数""1.字符串常量...
  • 字符串是字符的有序集合,可以通过其位置来获得具体的元素。在python中,字符串中的字符是通过索引来提取的,索引从0开始。 1:python中的索引:string[index] p='helloworld' print p[4] #结果是0 print p[-1] #...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 910
精华内容 364
关键字:

python集合转字符串

python 订阅