Python--基础二

Python基础：字符串str & 列表list & 元组tuple & 字典dict & 集合set

Python 基础 2

字符串 str

字符串是以单引号或双引号括起来的任意文本

字符串不可变

创建字符串
str1 = "lee is a good man!"
str2 = "lee is a nice man!"
str3 = "lee is a handsome man!"

字符串运算

字符串拼接

str6 = "lee is a "
str7 = "good man"
str8 = str6 + str7
print("str6 =", str6)
print("str7 =", str7)
print("str8 =", str8)

a="hello"+"-"*50+"world"
print(a)
print(a.__len__())
print(len(a))

输出重复字符串

输出重复字符串
str9 = "good"
str10 = str9 * 3
print("str10 =", str10)

访问字符串中的某一个字符

通过索引下标查找字符
字符串名[下标]
str11 = "lee is a good man!"
print(str11[1])
#str11[1] = "a" #打印会报错，因为字符串不可变
#print("str11 =", str11)

字符串取值（切片）

str12 = "to day is a good day"
print(str12[5:10])      # 从给定下标开始截取到给定下标之前
print(str12[:4])        # 从头截取到给定下标之前
print(str12[14:])       # 从给定下标处开始截取到结尾
print(str12[:])         # :号前后都省略，则表示全取列表所有的值；但这样写比较怪，不如直接print(str12)
print(str12[::2])       # 第一个:号前后都省略，表示全取，第二个:号后的数字2表示步长（和循环里的步长一致)
print(str12[::-1])      #列表反转，类似os.reverse()

字符串判断

str13 = "lee is a good man!"
print("good" in str13)
print("good" not in str13)

格式化输出

print("lee is a good man")
num = 10
str14 = "lee is a nice man!"
f = 10.14567
print("num =", num)
#      %d       %s      %f      占位符
#                                 %.2f 精确到小数后2位，会四舍五入
print("num = %d, str14 = %s, f = %.2f" %(num,str14,f))

字符串的方法

abc=" Hello,nice to meet you "
print(len(abc))                 # 打印字符串的长度
print(abc.__len__())            # 打印字符串的长度
print(abc.lower())              # 转换字符串中大写字母为小写字母
print(abc.upper())              # 转换字符串中小写字母为大写字母
print(abc.swapcase())           # 转换字符串中大写字母为小写字母，小写字母为大写字母
print(abc.capitalize())         # 整个字符串中首字母大写，其他全部小写
print(abc.title())              # 每个单词的首字母大写
print(abc.center(50, "*"))      # 一共50个字符,字符串放中间，不够的两边补*
print(abc.ljust(50, "*"))       # 一共50个字符,字符串放左边，不够的左边补*
print(abc.rjust(50, "*"))       # 一共50个字符,字符串放右边，不够的右边补*
print(abc.zfill(50))            # 一共50个字符,字符串放右边，不够的右边补0
print(abc.count("t"))           # 统计字符串里t出现了多少次
print(abc.find("to"))           # 找出to在字符串中的第几位
print(abc.rfind("to"))          # 找出最后一个to在字符串中的第几位
print(abc.index("to"))          # 和find一样的查找，只不过如果to不存在的时候会报一个异常
print(abc.rindex("to"))         # 和rfind一样的查找，只不过如果to不存在的时候会报一个异常
print(abc.endswith("you"))      # 判断是否以you结尾
print(abc.startswith("Hello"))  # 判断字符串是否以hello开始
print(abc.isalnum())            # 判断字符串中是否只有字母或数字
print(abc.isalpha())            # 判断字符串是否都是字母
print(abc.isdecimal())          # 判断字符串中是否只包含十进制字符
print(abc.isdigit())            # 判断字符串中是否只有数字
print(abc.islower())            # 判断字符串中的字符是否都是小写的英文字母
print(abc.isnumeric())          # 判断字符串中是否只有数字
print(abc.isspace())            # 判断字符串中是否只包含空格

print(abc.strip())              # 去掉字符串左右两端的空格或换行
print(abc.lstrip())             # 去掉字符串左边空格或换行
print(abc.rstrip())             # 去掉字符串右边空格或换行

#   eval(str)
#   功能：将字符串str当成有效的表达式来求值并返回计算结果
print(eval("+123"))
print(eval("-123"))
print(eval("12+3"))
print(eval("12-3"))

#   len(str)
#   返回字符串的长度(字符个数)
print(len("lee is a good man!"))

#   lower()
#   转换字符串中大写字母为小写字母
str15 = "LEE is a Good Man!"
print(str15.lower())

#   upper()
#   转换字符串中小写字母为大写字母
str16 = "LEE is a Good Man!"
print(str16.upper())
print("LEE is a Good Man!".upper())

#   swapcase()
#   转换字符串中大写字母为小写字母，小写字母为大写字母
str17 = "LEE is a Good Man!"
print(str17.swapcase())

#   capitalize()
#   首字母大写，其他小写
str18 = "LEE is a Good Man!"
print(str18.capitalize())

#   title()
#   每个单词的首字母大写
str19 = "LEE is a Good Man!"
print(str19.title())

#   center(width[,fillchar])
#   返回一个指定宽度的居中字符串，fillchar为填充的字符串,默认是空格填充
str20 = "lee is a nice man!"
print(str20.center(40,"*"))

#   ljust(width[,fillchar])
#   返回一个指定宽度的左对齐字符串，fillchar为填充的字符串,默认是空格填充
str21 = "lee is a nice man!"
print(str21.ljust(40,"%"))

#   rjust(width[,fillchar])
#   返回一个指定宽度的右对齐字符串，fillchar为填充的字符串,默认是空格填充
str22 = "lee is a nice man!"
print(str22.rjust(40,"%"))

#   zfill(width)
#   返回一个长度为width的字符串，原字符串右对齐，前面补0
str23 = "lee is a nice man!"
print(str23.zfill(40))

#   count(str[,start][,end])
#   返回字符串中strc出现的次数，可以指定一个范围，默认从头到尾
str24 = "lee is a very very nice man!"
print(str24.count("very"))
print(str24.count("very",9,len(str24)))

#   find(str[,start][,end])
#   从左向右检测str字符串是否包含在字符串中，可以指定范围，默认从头到尾，得到的是第一次出现的开始下标，没有返回-1
str25 = "lee is a very very nice man!"
print(str25.find("very"))
print(str25.find("good"))
print(str25.find("very",8,len(str25)))

#   rfind(str[,start][,end])
str25 = "lee is a very very nice man!"
print(str25.rfind("very"))
print(str25.rfind("good"))
print(str25.rfind("very",8,len(str25)))

#   index(str,start=0,end=len(str))
#   跟find()一样，只不过如果str不存在的时候会报一个异常
str26 = "lee is a very very nice man!"
print(str26.index("very"))

#   rndex(str,start=0,end=len(str))
#   跟rfind()一样，只不过如果str不存在的时候会报一个异常
str27 = "lee is a very very nice man!"
print(str27.rindex("very"))

#   lstrip()
#   截掉字符串左侧指定的字符，默认为空格
str28 = "*******lee is a nice man!"
print(str28.lstrip("*"))

#   rstrip()
#   截掉字符串右侧指定的字符，默认为空格
str29 = "lee is a nice man!       "
print(str29.rstrip(),"*")

#   strip()
#   截掉字符串两侧指定的字符，默认为空格
str30 = "******lee is a nice man******"
print(str30.strip("*"))

# 应用, 模拟用户登录. 忽略用户输入的空格
username = input("请输入用户名:").strip()
password = input("请输入密码: ").strip()
if username == 'xiaobai' and password == '':
    print("登录成功")
else:
    print("登录失败")

#  split(str="",num)
#  以str为分隔符截取字符串,指定num，则仅截取num个字符串
str31 = "lee***is*****a**good**man"
print(str31.split("*"))
list39 = str31.split("*")
c = 0
for s in list39:
    if len(s) > 0:
        c += 1
print(c)

#  splitlines([keepends])
#  按照('\r', '\r\n', '\n')分割
#  keepends == True  会保留换行符
str32 = '''
lee is a good man!
lee is a nice man!
lee is a handsome man!
'''
print(str32.splitlines())

#   join(seq)
#以指定的字符串分隔符，将seq中的所有元素组合成一个字符串
list33 = ['lee','is','a','good','man']
str33 = " ".join(list33)
print(str33)

#   max() min()
str34 = "lee is a good man z"
print(max(str34))
print("*"+min(str34)+"*")

#   replace(oldstr,newstr,count)
#   用newstr替换oldstr，默认是全部替换。如果指定了count，那么只替换前count个
str35 = "lee is a good good good man"
str36 = str35.replace("good","nice",1)
print(str36)

#   创建一个字符串映射表
#                      要转换的字符串， 目标字符串
str37 = str.maketrans("ac","")
#   a--6    c--5
str38 = "lee is a good man"
str39 = str38.translate(str37)
print(str39)

#   startswith(str,start=0,end=len(str))
#   在给定的范围内是否是以给定的字符串开头的，如果没有指定范围，默认整个字符串
str40 = "lee is a good man"
print(str40.startswith("lee",5,14))

#   endswith(str,start=0,end=len(str))
#   在给定的范围内是否是以给定的字符串结尾的，如果没有指定范围，默认整个字符串
str41 = "lee is a good man"
print(str41.endswith("man"))

#   编码
#encode(encoding="utf-8",errors="strict")
str42 = "lee is a good man杰"
#ignore 忽略错误
date42 = str42.encode("utf-8","ignore")
print(date42)

#   解码 注意：要与编码时的编码格式一致
str43 = date42.decode("gbk","ignore")
print(str43)

#   isalpha()
#   如果字符串中至少有一个字符且所有的字符都是字母返回True，否则返回False
str44 = "leeisagoodman"
print(str44.isalpha())

#   isalnum()
#   如果字符串中至少有一个字符且所有的字符都是字母或数字返回True，否则返回False
str45 = "12a3"
print(str45.isalnum())

#   isupper()
#   如果字符串中至少有一个英文字符且所有的字符都是大写的英文字母返回True，否则返回False
print("ABD".isupper())
print("AbC".isupper())
print("ABC".isupper())
print("ABD#".isupper())

#   islower()
#   如果字符串中至少有一个英文字符且所有的字符都是小写的英文字母返回True，否则返回False
print("abc".islower())
print("Abcd".islower())
print("ABCD".islower())
print("abc1".islower())
print("abc!".islower())

#   istitle()
#   如果字符串是标题化的返回True，否则返回False
print("Lee Is".istitle())
print("Lee is".istitle())
print("lee is".istitle())

#   isdigit()
#   如果字符串只包含数字字符返回True，否则返回False
print("".isdigit())
print("123a".isdigit()

#   isnumeric()
#   同上
print("".isnumeric())
print("123s".isnumeric())

#   isdecimal()
#   字符串中只包含十进制字符
print("".isdecimal())
print("123a".isdecimal())

#   如果字符串中只包含空格返回True，否则返回False
print(" ".isspace())
print("   ".isspace())
print("\t".isspace())
print("\n".isspace())
print("\r".isspace())

字符串方法示例大全

列表 list

列表是一种基本的序列数据结构，是一种可变值的数据类型；使用中括号表示[]

列表中的每个元素配有下标(或者叫索引); 第一个为0，第二个为1，以此类推,每个元素用逗号隔开，里面可以存放各种数据类型比如：

li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

格式：列表名 = [ 列表选项1, 列表选项2, ,,,,,, 列表选项n]

#创建一个空列表
list1 = []
print(list1)

#创建带有元素的列表
list2 = [18, 19, 20, 21, 22]
index = 0
sum = 0
#嵌套最好不要超过3层
while index < 5:
    sum += list2[index]
    index += 1
    if index == 5:
        print("平均年龄：%d" %(sum / 5))
#注意：列表中的元素数据可以是不同类型的
list3 = [1, 2, 3, "lee", "good", True]
print(list3)

增：

#   在列表的末尾添加新的元素
list12 = [1,2,3,4,5]
list12.append(6)
list12.append([7,8,9])
print(list12)

#   在末尾一次性追加另一个列表中的多个值
list13 = [1,2,3,4,5]
list13.extend([6,7,8])   # 迭代的去增
print(list13)

#   根据索引增加，不覆盖原数据，原数据向后顺延
list14 = [1,2,3,4,5]
list14.insert(3,100)
list14.insert(3,[44,22])
print(list14)

删：

#   pop(x=list[-1])
#   移除列表中指定下标处的元素（默认移除最后一个元素）,并返回删除的数据
list15 = [1,2,3,4,5]
list15.pop()
list15.pop(2)
print(list15.pop(1))
print(list15)

#   remove 移除列表中的某个元素第一个匹配的结果
list16 = [1,2,3,4,5,6,3,4,2]
list16.remove(4)
print(list16)

#   按照位置去删除，也可切片删除没有返回值
# del li[1:3]
# print(li)

#   清除列表中所有的数据
list17 = [1,2,3,4,5]
list17.clear()
print(list17)

改：

li = [1, 'a', 'b', 2, 3, 'a']
li[1] = "test"
print(li)
>打印结果
[1, 'test', 'b', 2, 3, 'a']

li[1:3] = ['A', 'B']
print(li)
>打印结果
[1, 'A', 'B', 2, 3, 'a']

查：

可以通过切片查， 或者通过循环去查

#列表元素的访问
#注意不要越界（下标超出了可表示的范围）
#取值 格式：列表名[下标]
list4 = [1, 2, 3, 4, 5]
print(list4[2])

os=["rhel","centos","suse"]
print(len(os))            #打印列表里元素的个数
print(max(os))            #打印最大元素
print(min(os))            #打印最小元素
print(os[0])              #取列表中的第一个
print(os[1])              #取列表中的第二个
print(os[2])              #取列表中的第三个
print(os[1:3])            #取列表中的第二个到第三个（注意:不包含第四个)
print(os[0:-1])           #取列表中的第一个到倒数第二个（注意:不包含最后一个)
print(os[2:])             #取列表中的第三个到最后一个
print(os[:2])             #取列表中的第一个到第二个（注意:不包含第三个)
print(os[:])              # :号前后都省略，则表示全取列表所有的值；但这样写比较怪，不如直接print(os)
print(os[::2])            # 第一个:号前后都省略，表示全取，第二个:号后的数字2表示步长（和循环里的步长一致)
print(os[::-1])           #列表反转，类似os.reverse()

其他方法

#   从列表中找出某个值第一个匹配的索引值
list18 = [1,2,3,4,5,3]
index18 = list18.index(3)
index19 = list18.index(3,3,6)
print(index18)
print(index19)

#   列表中元素的个数
list20 = [1,2,3,4,5]
print(len(list20))

#   获取列表中的最大值
list21 = [1,2,3,4,5]
print(max(list21)

#   获取列表中的最小值
list22 = [1,2,3,4,5]
print(min(list22))

#   倒序
list25 = [1,2,3,4,5]
list25.reverse()
print(list25)

#   升序排序
list26 = [2,3,4,1,5]
list26.sort()
print(list26)

#找出第二大的值
# 方法一
listNum = []
num = 0
while num < 10:
    val = int(input())
    listNum.append(val)
    num += 1
print(listNum)
listNum.sort()  #按照升序排序
count = listNum.count(listNum[len(listNum) -1])
c = 0
while c < count:
    listNum.pop()
    c += 1
print(listNum[len(listNum) -1])

# 方法二
listNum = []
num = 0
while num < 10:
    val = int(input())
    listNum.append(val)
    num += 1

if listNum[0] >= listNum[1]:
    max = listNum[0]
    sec = listNum[1]
else:
    max = listNum[1]
    sec = listNum[0]

index = 2
while index < len(listNum):
    if listNum[index] >= sec:
        sec = listNum[index]
    if listNum[index] >= max:
        sec = max
        max = listNum[index]
    index += 1
print(sec)

列表练习

元组 tuple

元组也是一种有序集合，与列表相似，一旦初始化就不能修改，使用小括号表示 ()

#创建tuple
#格式：元组名 = (元组元素1, 元组元素2, ……, 元组元素n)

#创建空的元组
tuple1 = ()
print(tuple1)

#创建带有元素的元组
#元组中的元素的类型可以不同
tuple2 = (1,2,3,"good",True)
print(tuple2)

#定义只有一个元素的元组
tuple3 = (1,)
print(tuple3)
print(type(tuple3))

元组的访问

#   元组元素的访问
#   格式：元组名[]
#   下标从0开始
tuple4 = (1,2,3,4,5)
print(tuple4[1])
print(tuple4[-1])   #   获取最后一个元素
print(tuple4[-2])

#   元组的截取
#   格式：元组名[开始下标:结束下标]
#   从开始下标开始截取，截取到结束下标之前
tuple12 = (1,2,3,4,5,6,7,8)
print(tuple12[3:7])
print(tuple12[3:])
print(tuple12[:7])

#   二维元组:元素为一维元组的元组
tuple13 = ((1,2,3),(4,5,6),(7,8,9))
print(tuple13[1][1])

#   判断元素是否在元组中
tuple11 = (1,2,3)
print(4 in tuple11)

元组的方法

#len()  返回元组中元素的个数
tuple14 = (1,2,3,4,5)
print(len(tuple14))

#max()  返回元组中的最大值
print(max((5,6,7,8,9)))
#min()  返回元组中的最小值
print(min(1,2,3,4,5))

#将列表转成元组
list1 = [1,2,3]
tuple15 = tuple(list1)
print(tuple15)

#元组的遍历
for i in (1,2,3,4,5):
    print(i)

删除元组

tuple6 = (1,2,3)
del tuple6
#print(tuple6)

字典 dict

　　字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

　　字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

{Key1:value2, Key2:value2}

1. 键与值用冒号“：”分开；
2. 项与项用逗号“，”分开；

key的特性

1、字典中的key必须唯一

2、key是不可变的对象

3、字符串、数字等都是不可变的，可以作为key

4、list是可变的，不能作为key

思考：保存多位学生的姓名与成绩
[["tom",60],["lilei",70]]

使用字典，学生姓名为key，学生成绩作为值
dict1 = {"tom":60, "lilei":70}

增：

dict1= {'stu01':'yun', 'stu02':'yu'}
dict1["stu05"]="tianqi"  #类似修改,如果key值不存在,则就增加
print(dict1)

# 如果dict中没有出现过这个key-value. 可以通过setdefault设置默认值 .setdefault(key, value)
dict1.setdefault("stu06", 'xue')   # 也可以往⾥⾯设置值, 如果dict中已经存在了，那么setdefault将不会起作用
print(dict1)

删：

dict1.pop("stu05")     # 删除这条记录值，返回删除的value

del dict1["stu05"]     # 删除这条记录值，

dict1.popitem()        # 删除显示的最后一条

dict1.clear()          # 清空字典

改：

dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic)  　　　　# 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
print(dic2)

dict1["stu04"]="马六"    #类似增加,如果key值存在,则就修改
print(dict1)

查：

print(dict1["stu01"])   #不建议这种方法,如果key值不存在,会返回keyerror错误

print(dict1.get("stu01"))  #这种取值方法如果key值不存在,会返回none,不会返回错误

其他操作

print("stu01" in dict1) #判断键stud01是否在字典里,在则返回True,不在则返回False

print(dict1.items())  #字典转成列表套元组

print(list(dict1))   #这种只能看到key

print(dict1.keys())   #打印所有的keys

print(dict1.values()) #打印所有的values

dict1.setdefault("stu08","老八")    #有这个key，则不改变；没有这个key，则增加这个key和value

# if "stu08" in dict1:
#     pass
# else:
#     dict1["stu08"]="老八"        #这个判断也可以实现setdefault的方法效果　

字典的循环

dict1 = {
    'stu01':"zhangsan",
    'stu02':"lisi",
    'stu03':"wangwu",
    'stu04':"maliu",
}

#建议用这种来做字典循环,效率高
for i in dict1:
    print(i,dict1[i])

#这种循环效率比上面的差
for i,j in dict1.items():
    print(i,j)

#只循环key
for i in dict1.keys():
    print(i)

#只循环value
for i in dict1.values():
    print(i)

字典的嵌套

dic = {'name':'汪峰',
       'age':43,
       'wife':{
           'name':'国际章',
           'age':39,
           'salary':100000
       },
       'baby':[
           {'name':'熊大','age':18},
           {'name':'熊二','age':15},
       ]
}

#找到熊大的年龄
print(dic['baby'][0]['age'])
#将熊大年龄改为19岁
dic['baby'][0]['age'] = 19
print(dic)

字典和列表的比较

#dict
#1、查找和插入的速度极快不会随着key-vaule的增加而变慢
#2、需要占用大量的内存，内存浪费多

#list
#1、查找和插入的速度会随着数据量的增多而减慢
#1、占用空间小，浪费内存少

#   输入一个单词，判断出现了多少次
w = input()
d = {} # word:次数
str = "lee is a good man! lee is a nice man! lee is a greate man! lee is a hands man! lee is a good man! lee is a noble man!"

l = str.split(" ")
for v in l:
    c = d.get(v)
    if c == None:
        d[v] = 1
    else:
        d[v] += 1
print(d[w])

'''
1、以空格切割字符串
2、循环处理列表中的每个元素
3、以元素当做key去一个字典中提取数据
4、如果没有提取到，就以该元素作为key，1作为value存进字典
5、如果提取到，将对应的key的value修改，值加1
6、根据输入的字符串当做key再去字典取值
'''

字典练习

集合 set

set类似dict，是一组key的集合，不存储value

本质：无序和无重复元素的集合

#创建
#创建set需要一个list或者tuple或者dict作为输入
#重复元素在set中会自动被过滤
set1 = set([1,2,3,4,5,5,4,3,3])
print(set1)

set2 = set((1,2,3,4,3,2))
print(set2)

set3 = set({1:"good",2:"nice"})
print(set3)

增：

# add ， update
set4 = set([1,2,3,4,5])
set4.add(6)
set4.add(4) 　　　　　　　　#可以添加重复的，但是不会有效果
#set4.add([7,8,9]) 　　　　#set的元素不能是列表，因为列表是可变的
set4.add((7,8,9))
#set4.add({4:"good"})     #set的元素不能是字典，因为字典也是可变的
print(set4)

#插入整个list、tuple、字符串，打碎插入
set5 = set([1,2,3,4,5])
set5.update([6,7,8])
set5.update((9,10))
set5.update("sunck")
print(set5)

删：

set6 = set([1,2,3,4,5])
set6.remove(3)       # remove删除一个不存在的元素会报错
print(set6)

set6.discard(666) 　　# discard删除一个不存在的元素不会报错，存在则删除
print(set1)

集合的方法

set1=[1,4,7,5,9,6]
set2=set([2,4,5,9,8])
# 交集
print(set1.intersection(set2))
print(set1 & set2)
print(set1.isdisjoint(set2))  # 判断两个集合是否有交集,有则返回true;没有则返回false

# 并集
print(set1.union(set2))
print(set1 | set2)

# 差集（补集）
print(set1.difference(set2)) #set1里有,set2里没有
print(set1-set2)
print(set2.difference(set1)) #set2里有,set1里没有
print(set2-set1)

# 对称差集
print(set1.symmetric_difference(set2))#我有你没有的  加上 你有我没有的
print(set1^set2)

# 子集
set3=set([4,5])
print(set3.issubset(set1)) 　　 #判断set3是否为set1的子集
print(set1.issuperset(set3))　　#判断set1是否包含set3

# 遍历
set7 = set([1,2,3,4,5])
for i in set7:
    print(i)
# set没有索引
# print(set7[2])

for index,i in enumerate(set7):
    print(index,i)

基础数据类型的总结

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按存值个数区分

标量／原子类型	数字，字符串
容器类型	列表，元组，字典

按可变不可变区分

可变	列表，字典
不可变	数字，字符串，元组，布尔值

按访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典

类型转换

#list > set
l1 = [1,2,3,4,5,5,3,2,5,6,9]
print(set(l1))

#tuple > set
t1 = (1,2,3,4,4,5,2)
print(set(t1))

#set > list
s1 = {1,2,3,4}
print(list(s1))

#set > tuple
s2 = {1,2,3,4,5}
print(tuple(s2))