首页 > 编程语言 > 详细

Python基本数据类型

时间:2019-06-15 00:56:49      阅读:141      评论:0      收藏:0      [点我收藏+]

Python基本数据类型

一、Python基本数据类型

  1. int ==> 整数. 主要?来进?数学运算

  2. str ==> 字符串, 可以保存少量数据并进?相应的操作

  3. bool==>判断真假, True, False

  4. list==> 存储?量数据.?[ ]表?

  5. tuple=> 元组, 不可以发?改变 ?( )表?

  6. dict==> 字典, 保存键值对, ?样可以保存?量数据

  7. set==> 集合, 保存?量数据. 不可以重复. 其实就是不保存value的dict

二、整数(int)

在Python 3 中所有的整数都是int类型,但在Python 2 中如果数据量较大则会采用 long类型,而在Python 3 中没有long类型。

常用方法:

? 1、bit_length():计算整数在计算机中占用的二进制数的长度。

三、布尔值(bool)

取值只有True和False。

转换问题:

  1. str ==> int int(str)
  2. int ==> str str(int)
  3. int ==> bool bool(int) 0为False,非0位True
  4. bool ==> int int(bool) True为1,False为0
  5. str ==> bool bool(str) 空为False,非空为True
  6. bool ==> str str(bool) 把bool值转换成相应的"值"

四、字符串(str)

字符串:把字符连成串. 在python中?‘, ", ‘‘‘, """引起来的内容被称为字符串.

  1. 索引和切片

    索引:索引指的就是下标,索引从0开始。

    切片:截取字符串指定部分的内容。

    ? 语法:str[起始位置,结束位置,步长]

    ? 规则:“顾头不顾尾”,即包含起始位置,但不包含结束位置。

    ? 步长:如果是整数,则从左往右取,如果是负数,则从右往左取,默认是1。

    content = "生活不止眼前的苟且,以后还有一大堆的苟且。"
    例:截取“眼前的苟且,以后还有”
    print(content[4:14])
    例:截取“生不眼的且以还一堆苟”
    print(content[::2])
    例:将内容翻转
    print(content[::-1])
    例:截取“一有还后以,且苟的前”
    print(content[14:4:-1])
    例:截取“止眼前的苟且,以后还有一大堆的苟且。”
    print(content[3:])
    
  2. 字符串其它相关方法

    注意:切记, 字符串是不可变的对象, 所以任何操作对原字符串是不会有任何影响的。

    1. 字符串中的字母全部大写

      content = “dogfa is a verv beautiful boy!”
      content = content.upper()
      print(content)
      ==>"DOGFA IS A VERV BEAUTIFUL BOY!"
    2. 字符串中的字母全部小写

      content = “DOGFA IS A VERV BEAUTIFUL BOY!”
      content = content.lower()
      print(content)
      ==>"dogfa is a verv beautiful boy!"
    3. 英文首字母大写

      content = “dogfa is a verv beautiful boy!”
      content = content.capitalize()
      print(content)
      ==>"Dogfa is a verv beautiful boy!"
    4. 大小写转换

      content = “dOgfA iS A verv beautiful boy!”
      content = content.swapcase()
      print(content)
      ==>"DoGFa Is a VERV BEAUTIFUL BOY!"
    5. 每个被特殊字符隔开的单词首字母大写

      content = "dogfa is a verv beautiful boy!"
      content = content.title()
      print(content)
      ==>"Dogfa Is A Verv Beautiful Boy!"
    6. 居中

      content = "欢迎光临~"
      content = content.center(15, "*")     #将长度拉长为15,两边用‘*’填充
      print(content)
      ==> "*****欢迎光临~*****"
    7. 清除空格

      content = "   其实世上本没有路,走的人多了也就成了路     "
      content = content.strip()     #清楚两端空格
      print(content)
      ==> "其实世上本没有路,走的人多了也就成了路"
      
      str.lstrip()      # 清除左端空格
      str.rstrip()      # 清楚右端空格
      str.strip("明")        # 清除左右两端的“明”
      
      content = "明天到操场操到天明"
      content = content.strip("明")
      print(content)
      ==> "天到操场操到天"
      
    8. 字符串替换

      content = "明天到操场操到天明"
      content = content.replace("操", "*")
      print(content)
      ==> "明天到*场*到天明"
      
      str.replace("需要替换的字符串", "替换为的字符串", "替换数量")    # 替换数量默认为全部替换
      content = content.replace("操", "*", 1)
      print(content)
      ==> "明天到*场操到天明"
    9. 字符串切割

      content = "清明时节雨纷纷,路上行人欲断魂,借问酒家何处有,牧童遥指杏花村"
      content = content.split(",")
      print(content)
      ==> "['清明时节雨纷纷', '路上行人欲断魂', '借问酒家何处有', '牧童遥指杏花村']"
      
      content = content.split("清")
      print(content)
      ==> "['', '明时节雨纷纷,路上行人欲断魂,借问酒家何处有,牧童遥指杏花村']"
      
      注意:如果切割点在开头或者结尾,都将会在列表的开头或结尾产生一个空字符串。
    10. 格式化输出

      例:要求输入以下内容
      *********Welcome~*********
      name: dogfa
      age: 80
      job: piaoke
      hobby: piaochang
      **************************
      
      我们可以这样:
      info = '''*********Welcome~*********
      name: {0}
      age: {1}
      job: {2}
      hobby: {3}
      **************************'''
      name = "dogfa"
      age = 80
      job = "piaoke"
      hobby = "piaochang"
      print(info.format(name, age, job, hobby))
      
      我们也可以这样:
      info = '''*********Welcome~*********
      name: {name}
      age: {age}
      job: {job}
      hobby: {hobby}
      **************************'''
      name2 = "dogfa"
      age2 = 80
      job2 = "piaoke"
      hobby2 = "piaochang"
      print(info.format(name=name2, age=age2, job=job2, hobby=hobby2))
      
    11. 查找

      content = "明天到操场操到天明"
      content = content.find("操")
      print(content)
      ==> 3(返回的是下标)
      
      str.find("查找内容", "起始位置", "结束位置")     # 切片查找
      content = content.find("操", 4, 7)
      print(content)
      ==> 5
      
      注意:只能查找到第一个内容的索引,查找不到时将会返回"-1"。
      
      
      
      str.index("查找内容")
      content = content.index("操")
      print(content)
      ==> 3
      
      注意:查找不到内容时将会直接抛出异常。建议使用find()。
      
      
      str.startswith("明")      # 判断字符串是否以“明”开头
      str.endswith("明")        # 判断字符串是否以“明”结尾
      content = content.startswith("明")
      ==> True
      content = content.endswith("明")
      ==> True
    12. 条件判断

      # 判断是否为纯数字
      str.isdigit()
      content = "123456"
      content = content.isdigit()
      print(content)
      ==> True
      
      content = "123456abc"
      content = content.isdigit()
      print(content)
      ==> False
      
      # 判断是否为纯英文
      str.isalpha()
      content = "abcde"
      content = content.isalpha()
      print(content)
      ==> True
      
      content = "123456abc"
      content = content.isalpha()
      print(content)
      ==> False
      
      # 判断是否由数字和字母组成
      str.isalnum()
      content = "abcde123456"
      content = content.isalnum()
      print(content)
      ==> True
      
      content = "@123avb"
      content = content.isalnum()
      print(content)
      ==> False
      
      
      # 其它
      str.isdecimal()
      str.isnumeric()      # 这个可以判断中文
      content = "壹仟伍佰"
      content = content.isnumeric()
      print(content)
      ==> True
    13. 计算字符串的长度

      content = "你猜我有多长?"
      print(len(content))
      ==> 7
      
      注意:注意: len()是python的内置函数. 所以访问?式也不?样。
    14. 字符串的拼接

      content = "嘿嘿嘿"
      content = "_".join(content)
      print(content)       # 嘿_嘿_嘿
    15. 迭代

      for "变量" in "可迭代对象":
       pass
      
      
      content = "喜欢唱跳rap篮球"
      for item in content:
          print(item)
      
      ==> 喜
          欢
          唱
          跳
          r
          a
          p
          篮
          球
      
      
      可迭代对象:简单来说就是可以一个一个往外取值的对象,如str, list, tuple。

五、列表(list)

1、列表的介绍

列表:列表是Python的基础数据类型之? ,其他编程语?也有类似的数据类型. 比如JS中的数
组, java中的数组等等. 它是以[ ]括起来, 每个元素?‘ , ‘隔开?且可以存放各种数据类型:

例:

lst = ["嘿嘿", "吼吼", ["我是", "列表"], ("I'm", "tuple"), {"dict": "我是字典"}, {"set", "我是集合呀"}, 2]

列表相比于字符串可以存取更多类型的数据,而且可以存放大量的数据。列表是有序的,可以通过索引对列表进行切片取值等操作。

2、列表的索引和切片

列表和字符串一样拥有索引

lst = ["孙悟空", "猪八戒", "沙僧", "唐僧"]
print(lst[0])       # 孙悟空
print(lst[1])       # 猪八戒
print(lst[2])       # 沙僧
print(lst[3])       # 唐僧

lst[0] = "齐天大圣"     # 注意:列表是可变类型,可以直接发生改变,和字符串不一样哈
print(lst)      # ["齐天大圣", "猪八戒", "沙僧", "唐僧"]
temp = "天蓬元帅"
temp[0] = "地"
print(temp)     # TypeError: 'str' object does not support item assignment (不可变类型)

列表的切片

lst = ["孙悟空", "猪八戒", "沙僧", "唐僧"]
print(lst[0:2])     # ["孙悟空", "猪八戒", "沙僧"]
print(lst[::2])     # ["孙悟空", "沙僧"]
print(lst[::-1])    # ['唐僧', '沙僧', '猪八戒', '孙悟空']
print(lst[-1:1:-1]) # ["唐僧", "沙僧"]

3、列表的增删该查

注意:列表是可变类型,所以可以直接对列表中的元素进行操作。

  1. lst = ["name", "age", "job", "hobby"]
    lst.append("gender")
    print(lst)       # ["name", "age", "job", "hobby", "gender"]
    
    lst = ["name", "age", "job", "hobby"]
    lst.insert(1, "gender")
    print(lst)       # ["name", "gneder", "age", "job", "hobby"]  按照索引进行插入
    
    lst = ["name", "age", "job", "hobby"]
    lst.extend(["gender", "salary"])
    print(lst)       # ["name", "age", "job", "hobby", "gender", "salary"]  将可迭代对象进行迭代添加
    lst = ["name", "age", "job", "hobby"]
    lst.extend("hello")
    print(lst)       # ['name', 'age', 'job', 'hobby', 'h', 'e', 'l', 'l', 'o']
  2. lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
    ret1 = lst.pop()     # 默认删除列表最后一个元素,并且可以取得被删除的元素的值
    ret2 = lst.pop(1)        # 也可以指定索引删除
    print(ret1)      # 格斗家
    print(ret2)      # 神枪手
    print(lst)       # ["鬼剑士", "召唤师", "圣职者"]
    
    lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
    lst.remove("圣职者")        # 指定列表中的元素名称进行删除,删除不存在的元素会报错
    print(lst)       # ["鬼剑士", "神枪手", "召唤师", 格斗家"]
    
    lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
    del lst[2]       # 使用del删除指定的列表元素,只能使用索引或者切片进行删除
    print(lst)       # ["鬼剑士", "神枪手",  "圣职者", "格斗家"]
    
    lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
    lst.clear()      # 清空列表
    print(lst)       # []
  3. lst = ["马云", "马化腾", "马良", "马蓉", "马克思"]
    lst[1] = "麻花藤"
    print(lst)       # ["马云", "麻花藤", "马良", "马蓉", "马克思"]
    
    lst = ["马云", "马化腾", "马良", "马蓉", "马克思"]
    lst[1:4] = "hello"
    print(lst)       # ["马云", "h", "e", "l", "l", "o", "马克思"]
  4. 列表是一个可迭代对象,所以可以使用for循环查询

    for ele in list:
     print(i)
  5. 其它操作

    # 计算"行者孙"在列表中出现的次数
    lst = ["孙行者", "行者孙", "者行孙", "行者孙"]
    print(lst.count("行者孙"))      # 2
    
    # 计算列表的长度
    lst = ["孙行者", "行者孙", "者行孙", "行者孙"]
    print(len(lst))      # 4
    
    # 对列表元素进行翻转
    lst = ["孙行者", "行者孙", "者行孙", "行者孙"]
    lst.reverse()
    print(lst)   # ["行者孙", "者行孙", "行者孙", "孙行者"]
    
    # 对列表进行排序
    lst = [10,2,45,64,4,16,8]
    lst.sort()       # 默认从小到大排序
    print(lst)       # [2, 4, 8, 10, 16, 45, 64] 
    
    lst.sort(reverse=True)   # 加上参数reverse=True变成从大到小排序
    print(lst2)      # [64, 45, 16, 10, 8, 4, 2] 

4、列表的嵌套

lst = [1, "夸父", "dogfa", ["jack ma", ["康帅博"], "麻辣干子"]]
# 找到"夸父"
print(lst[1])

# 找到“夸父“和”dogfa”
print(lst[1:3])

# 将"夸父“替换成”夸母”
lst[1] = lst[1].replace("父", "母")
print(lst)

# 将”jack ma“各个首字母大写
lst[3][0] = lst[3][0].title()
print(lst)

# 将”康帅博“替换成”康师傅“
lst[3][1][0] = lst[3][1][0].replace("帅博", "师傅")
print(lst)

# 将”dogfa“首字母大写
lst[2] = lst[2].capitalize()
print(lst)

5、循环删除列表中的元素(注意)

lst = ["鬼剑士", "神枪手", "召唤师", "圣职者", "格斗家"]
for  i in lst:
    lst.remove(i)
print(lst)      # ['神枪手', '圣职者']
# 为什么我们进行for循环时没有将列表中的元素全部删除?因为for循环每循环一次内部索引会加1,而删除了列表中的元素之后,后面的元素会前移,导致删除错乱。
# 第一次循环: ["神枪手", "召唤师", "圣职者", "格斗家"] 删除索引0对应的元素,后面的元素前移
# 第二次循环: ["神枪手", "圣职者", "格斗家"] 删除索引1对应的元素,后面的元素前移
# 第三次循环: ["神枪手", "圣职者"] 删除索引2对应的元素,后面的元素前移

# 解决办法1
for i in range(len(lst)):
    lst.pop()
print(lst)      # []

# 解决办法2
lst2 = []
for i in lst:
    lst2.append(i)
    
for el in lst2:
    lst.remove(el)
print(lst)      # []

六、元祖(tuple)

元组: 俗称不可变的列表.?被成为只读列表, 元组也是python的基本数据类型之?, ??括
号括起来, ??可以放任何数据类型的数据, 查询可以. 循环也可以. 切片也可以. 但就是不能
改.

tu = ("name", "age", "gender")
print(tu)       # ("name", "age", "gender")
print(tu[0])    # name
print(tu[2])    # gender
print(tu[0:2])  # 元祖切片之后还是元祖

# for循环遍历元祖
for ele in tu:
    print(ele)
    
# 尝试修改元祖
tu[0] = "我就是要改变你"   # TypeError: 'tuple' object does not support item assignment (元祖中的元素不支持被修改)

# 再次尝试修改元祖
tu = ("你改不了我的", [], "你也改不了我的", "我们中出了一个叛徒")
tu[1] = "我是叛徒"  # 再次修改失败
tu[1].append("我是叛徒")        # 修改成功
print(tu)   # ("你改不了我的", ["我是叛徒"], "你也改不了我的", "我们中出了一个叛徒")

# 通过以上结论,我们可以得出:元祖的不可变指的是元祖内的子元素不可变,而子元素的子元素可不可变取决于是否是可变类型的对象。
# 注意:当元祖中只有一个元素时,必须在元素后面加上一个逗号,否则就不是元祖,例:tu = ("name",)
# 元祖同样含有len(), index(), count()方法。

七、字典(dict)

1、字典的简单介绍

字典(dict)是Python中唯?的?个映射类型.他是以{ }括起来的键值对组成. 在dict中key是
唯?的. 在保存的时候, 根据key来计算出?个内存地址. 然后将key-value保存在这个地址中.
这种算法被称为hash算法, 所以, 切记, 在dict中存储的key-value中的key‘必须是可hash的。

可hash的数据类型:int,str,bool,tuple

不可hash的数据类型:list,dict,set

语法:{key: value, key2: value2 ...}

注意: key必须是可哈希(不可变类型)的. value没有要求.可以保存任意类型的数据

# 以下为正确字典格式
dic = {1: 123, "name": "oldniu", False: True, (1, 2, 3): (11, 22, 33)}
print(dic[1])
print(dic["name"])
print(dic[False])
print(dic[(1, 2, 3)])

# 以下是不正确的字典格式
dic = {[1, 2]: "我咋就不合法呢"}   # TypeError: unhashable type: 'list'
dic = {{"name": "dogfa"}: "兄嘚我也是不合法的"}  # TypeError: unhashable type: 'dict'
dic = {{"age", "hobby"}: "想不到吧,我也是不合法的"}    # TypeError: unhashable type: 'set'

注意:dict保存的数据不是按照我们添加进去的顺序保存的. 是按照hash表的顺序保存的. ?hash表
不是连续的. 所以不能进?切片?作. 它只能通过key来获取dict中的数据

2、字典的其它相关操作

  1. dic = {"age": 18}
    dic["name"] = "李白"
    print(dic)       # {"name": "李白", "age": 18}
    dic["age"] = 20
    print(dic)       # {"name": "李白", "age": 20}
    # 如果key不存在,则是执行添加操作,如果key存在,则是执行修改操作
    
    dic = {"age": 18}
    print(dic.setdefault("name", "杜甫"))      # 杜甫
    print(dic)       # {"age": 18, "name": "杜甫"}
    print(dic.setdefault("age", 20))      # 18
    print(dic)       # {"age": 18, "name": "杜甫"}
    # setdefault()的第一个参数为key,第二个参数为value。如果key不存在,则执行添加操作并返回对应的value,如果key存在,则执行查询操作返回字典中对应的key的value。
  2. dic = {"name": "Jack Ma", "age": 38, "gender": "man"}
    print(dic.pop("name"))       # Jack Ma
    print(dic)           # {"age": 38, "gender": "man"}
    # 因为dict在存储时不是连续的,所以pop在删除时不能指定索引,须指定key进行删除并会返回当前值。
    
    dic = {"name": "Jack Ma", "age": 38, "gender": "man"}
    del dic["name"]
    print(dic)       # {"age": 38, "gender": "man"}
    
    dic.popitem()    # 随机删除
    dic.clear()      # 清空字典
  3. dic1 = {"id": 1, "name": "马云", "salary": 100000000}
    dic2 = {"age": 38, "name": "马化腾"}
    dic1.update(dic2)        # 将dict2中的内容更新值dict1中,如果key存在则覆盖,key不存在则添加
    print(dic1)      # {'id': 1, 'name': '马化腾', 'salary': 100000000, 'age': 38}
    print(dic2)      # {'age': 38, 'name': '马化腾'}
  4. dic = {"id": 1, "name": "电视机", "price": 1000}
    print(dic["price"])      # 1000
    print(dic["age"])        # 报错
    print(dic.get("name"))   # 电视机
    print(dic.get("age"))    # None
    print(dic.get("age", 20))    # 20
    # 当直接对字典通过key取值时,如果存在key,可以取出对应的值,如果不存在key,则会报错。所以建议使用get()方法,当key不存在时,它会返回一个None,你也可以在下一个参数指定key不存在时的返回值。
    
    print(dic.setdefault("name"))    # 电视机
  5. 其它相关操作

    dic = {"id": 1, "fruit": "apple", "price": 10}
    print(dic.keys())        # dict_keys(['id', 'fruit', 'price'])
    for key in dic.keys():
     print(key)
    
    print(dic.values())      # dict_values([1, 'apple', 10])
    for value in dic.values():
     print(value)
    # dic.keys()和dic.values()得到的值和列表很像,但是不是列表,但可以当做列表来进行for循环使用。
    
    for i in dic:
     print(i,dic[i])         
     # id 1
    ==>  # fruit apple
     # price 10
    # 当对字典进行for循环时,得到的元素是key。
    
    print(dic.items())       # dict_items([('id', 1), ('fruit', 'apple'), ('price', 10)])
    for k,v in dic.items():
        print(k,v) 
     # id 1
    ==>  # fruit apple
     # price 10
    # dic.items()得到的是类似列表里面嵌套元祖的格式,对dic.items()进行for循环时,得到了里面的元祖。
    # 由于 a, b = (1, 2)可以推出 k, v = ("id", 1),所以k,v 分别对应字典中的key和value。
  6. 字典的嵌套

    dic = {
     "id": 9527,
     "name": "周星星",
     "age": 40,
     "movies": ["功夫", "少林足球", "算死草", "逃学威龙"],
     "partner": {
         "name": "逼王达",
         "age": 45,
         "children": ["老大", "老二", "老三"]
     },
     "desc": "别人笑我太疯癫,我笑他人看不穿"
    }
    
    # 获取"别人笑我太疯癫,我笑他人看不穿"
    print(dic["desc"])
    
    # 获取周星星的合作伙伴名字
    print(dic.get("partner").get("name"))
    
    # 获取“逃学威龙”
    print(dic.get("movies")[3])
    
    # 获取逼王达的第二个孩子名字
    print(dic.get("partner").get("children")[1])
  7. 字典中的fromkeys()(注意)

    dic = dict.fromkeys(["dogfa", "oldniu"], (1, 2))
    print(dic)   # {"dogfa": (1, 2), "oldniu": (1, 2)}
    # fromkeys()用于重新生成一个新的字典,第一个参数中的每一项都会作为新的字典的key,第二个参数作为value。
    
    dic = dict.fromkeys(["dogfa", "oldniu"], [1, 2])
    dic.get("dogfa").append(3)
    print(dic)   # {"dogfa": [1, 2, 3], "oldniu": [1, 2, 3]}

八、集合(set)

set集合是python的?个基本数据类型. ?般不是很常?. set中的元素是不重复的.?序的.?
?的元素必须是可hash的(int, str, tuple,bool), 我们可以这样认为, set就是dict类型的数据但
是不保存value, 只保存key. set也?{}表?。

注意:set中的元素必须是可hash的,但是set本身不是可hash的,set是可变类型数据。

set = {1, "2", True, [1, 2]}    # TypeError: unhashable type: 'list'
set = {1, "2", True, {1: 2}}    # TypeError: unhashable type: 'dict'
set = {1, "2", True, {1, 2}}    # TypeError: unhashable type: 'set'

由于set中的元素是不重复的,无序的,所以我们可以利用这个特性对列表进行去重操作。

lst = ["哈哈哈", 1, "嘿嘿嘿", "哈哈哈", "dsb", True, 1]
print(list(set(lst)))   # [1, 'dsb', '嘿嘿嘿', '哈哈哈']

set的相关操作

  1. s = {1, 2, 3}
    s.add(4)
    print(s) # {1, 2, 3, 4}
    
    s = {1, 2, 3}
    s.update([4, 5, 6])      # 迭代更新
    print(s) # {1, 2, 3, 4, 5, 6}
    # 已存在的元素将不会被添加进去
  2. s = {1, 2, 3}
    s1 =s.pop()      # 随机删除
    print(s) # {2, 3}
    print(s1)    # 1
    
    s = {1, 2, 3}
    s.remove(2)
    print(s) # {1, 3}
    # 对不存在的元素进行删除时将会报错
    
    s = {1, 2, 3}
    s.clear()
    print(s) # set()
    # 清空之后打印输出的是set(),是为了和dict区分开
  3. # 由于集合是没有索引,无序的,所以我们对几个进行删除时不能通过索引的方式来删除
    # 修改方法1:首先通过remove()删掉需要修改的的元素,然后add()添加新元素。
    s = {1, 2, 3}    # 将1改成10
    s.remove(1)
    s.add(10)
    print(s) # {10, 2, 3}
    
    # 修改方法2:将集合通过list()转换成列表,再通过对列表进行修改操作。
  4. for i in s:
     print(i)
  5. 其它常用操作

    # 求两个集合中的交集
    s1 = {"狗法", "oldniu", "djb"}
    s2 = {"狗法", "oldniu", "djb", "dsb"}
    print(s1.intersection(s2))   # {"狗法", "oldniu", "djb"}
    print(s1 & s2)   # {"狗法", "oldniu", "djb"}
    
    # 求两个集合中的并集
    s1 = {"狗法", "oldniu", "djb"}
    s2 = {"狗法", "oldniu", "djb", "dsb"}
    print(s1.union(s2))  # {"狗法", "oldniu", "djb", "dsb"}
    print(s1 | s2)   # {"狗法", "oldniu", "djb", "dsb"}

Python基本数据类型

原文:https://www.cnblogs.com/wangyueping/p/11026020.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!