基本数据类型及内置方法

整型（int）

　　1、类型转换

num = '123'
print(type(num))    #<class 'str'>
num = int(num)
print(type(num))    #<class 'int'>

　　ps：int在类型转换的时候，只能转换纯整数数字。不识别小数点、以及数字之外的数据。

　　2、进制数转换

print(bin(100))  # 将十进制的100转换成二进制  0b1100100
print(oct(100))  # 将十进制的100转换成八进制  0o144
print(hex(100))  # 将十进制的100转换成十六进制  0x64
# 0b开头为二进制数  0o开头为八进制数  0x开头为十六进制数
print(int('0b1100100', 2))  # 100
print(int('0o144', 8))  # 100
print(int('0x64', 16))  # 100

浮点型（float）

　　类型转换

num = '12.3'
print(type(num))    # <class 'str'>
num = float(num)
print(type(num))    # <class 'float'>

字符串（str）

　　1、类型转换

# 整型
num = 123
print(type(num))    # <class 'int'>
num = str(num)
print(type(num))    # <class 'str'>
# 浮点型
num = 12.3
print(type(num))    # <class 'float'>
num = str(num)
print(type(num))    # <class 'str'>
# 列表
num = [111, 222, 333]
print(type(num))    # <class 'list'>
num = str(num)
print(type(num))    # <class 'str'>
# 字典
num = {'k1': 111, 'k2': 222, 'k3': 333}
print(type(num))  # <class 'dict'>
num = str(num)
print(type(num))  # <class 'str'>
# 元组
num = (111, 222, 333)
print(type(num))  # <class 'tuple'>
num = str(num)
print(type(num))  # <class 'str'>
# 集合
num = {111, 222, 333}
print(type(num))  # <class 'set'>
num = str(num)
print(type(num))  # <class 'str'>

　　3、使用

　　　　3.1优先掌握的操作

res = 'hello world'
# 1.按索引取值(正向取，反向取.只能取不能改)：
# 1.1 正向取(从左往右)
print(res[2])   # l
# 1.2 反向取(负号表示从右往左)
print(res[-4])  # o
# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到8的所有字符
print(res[0:9])     # hello wor
# 2.2 步长：0:9:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2、4、6、8的字符
print(res[0:9:2])    # hlowr
# 2.3 反向切片
print(res[::-1])  # -1表示从右往左依次取值    #dlrow olleh
# 3.长度len
# 3.1 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符)
print(len(res))  # 空格也算字符   # 11
# 4.成员运算 in 和 not in
# 4.1 in:判断hello 是否在 res里面
print('hello' in res)   # True
# 4.2 not in:判断python 是否不在 res里面
print('python' not in res)  # True
# 5.strip移除字符串首尾指定的字符(默认移除空格)
# 5.1 括号内不指定字符，默认移除首尾空白字符(空格、\n、\t)
res1 = '  hello world  '
print(res1.strip())  # hello world
# 5.2 括号内指定字符，移除首尾指定的字符
res2 = '**hello world**'
print(res2.strip('*'))  # hello world
# 6.切分split
# 6.1 括号内不指定字符，默认以空格作为切分符号
res3 = 'hello world'
print(res3.split())  # ['hello', 'world']
# 6.2 括号内指定分隔字符，则按照括号内指定的字符切割字符串
res4 = 'hello*world'
print(res4.split('*'))  # ['hello','world']  注意:split切割得到的结果是列表数据类型
# 7.循环
res5 = 'hello world'
for i in res5:  # 依次取出字符串中每一个字符
    print(i)
# h
# e
# l
# l
# o
# 
# w
# o
# r
# l
# d

　　　　3.2、需要掌握的操作

　　　　 strip、lstrip、rstrip(移除指定字符)

name = '***tony***'
print(name.strip('*'))  # tony(strip  移除左右两边的指定字符)
print(name.lstrip('*'))  # tony***(lstrip  移除左边的指定字符)
print(name.rstrip('*'))  # ***tony(rstrip  移除右边的指定字符)

　　　　lower(),upper()(大小写转换)

username = 'MY NAME IS TONY'
print(username.lower())  # my name is tony(lower() 将英文字符串全部变成小写)
username1 = 'my name is tony'
print(username1.upper())  # MY NAME IS TONY(upper() 将英文字符串全部变成大写)

# 判断是否是纯大写
print(res.isupper())
print(res1.isupper())
# 判断是否是纯小写
print(res.islower())
print(res1.islower())

　　实际案例

"""实际案例:图片验证码忽略大小写
    思路:全部转大写或者小写再比对
"""
# old_code = 'JaSon123'
# print('这是返回给用户的图片验证码:%s' % old_code)
# new_code = input('请输入验证码>>>:').strip()
# if old_code.upper() == new_code.upper():  # 这里也可以使用lower()
#     print('验证码正确')
# else:
#     print('验证码错误')

　　　startswith,endswith(判断是否已指定字符开头结尾)

username = 'my name is tony my name is tony my name is tony'
print(username.startswith('m'))  # True(startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False)
print(username.startswith('y'))  # False
print(username.endswith('y'))  # True(endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False)
print(username.endswith('m'))  # False

　　　　format(格式化输出)　

# 1、与用户交互 占位符 %s,%d
# 2、字符串内置方法 format()
# 第一种方法:相当于占位符
res = 'my name is {}, my age is {}'
print(res.format('tony', 18))  # my name is tony, my age is 18
# 第二种方法：大括号写索引值可以打破顺序，并且可以反复使用相同位置的数据
res1 = '{1} my name is {1} {0}, my age is {0} {1} {0}'
print(res1.format('tony', 18))  # 18 my name is 18 tony, my age is tony 18 tony
# 第三种方法：大括号写变量名
res3 = 'my name is {name}, my age is {age}'
print(res3.format(name='tony', age=18))  # my name is tony, my age is 18
# 占位符于format结合具体情况使用

　　　　split,rsplit(字符切割)

res = '|hello|world|'
print(res.split('|', 1))  # ['', 'hello|world|'] (split会按照从左到右的顺序对字符串进行切分，可以指定切割次数)
print(res.rsplit('|', 1))  # ['|hello|world', ''] (rsplit会按照从右到左的顺序对字符串进行切分，可以指定切割次数

　　　　join(字符串拼接）

# 第一种:字符串相加
print('hello' + 'world')  # helloworld(不推荐)
# 第二种:join方法
l = ['my', 'name', 'is', 'tony' '|']
print('|'.join(l))  # my|name|is|tony|(join会按照指定的符号把字符串进行相加
print('*'.join(l))  # my*name*is*tony|
# 必须是字符串，在python中不同数据类型之间是无法操作的

　　　　replace(替换字符串中指定的字符)

username = 'my name is tony, my age is 18'
print(username.replace('tony', 'tom'))  # my name is tom, my age is 18(字符串tony替换成tom)
username1 = 'my name is tony tony tony, my age is 18'
print(username1.replace('tony', 'tom', 1))  # my name is tom tony tony, my age is 18(替换指定个数的文本)

　　　　isdigit(判断字符串中是否是纯数字)

name = 'tony123'
print(name.isdigit())  # False
age = '18'
print(age.isdigit())  # True

　　　　3.3、需要了解的操作

# 1.find,rfind,index,rindex,count
# 1.1 find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
name = 'tony, tony, tony, tony'
print(name.find('o'))  # 1
print(name.find('o', 2, 9))  # 7
print(name.find('o', 2, 5))  # -1
# 1.2 index:同find,但在找不到时会报错
name1 = 'tom, tom, tom, tom'  # 找不到时，报错ValueError
print(name.index('o', 2, 5))
# 1.3 rfind与 rindex同find与index，顺序不同
name = 'tony, tony, tony, tony'  # 从右往左
print(name.rfind('o'))  # 19
# 1.4 count:统计字符串在大字符串中出现的次数
res = "hello world"
print(res.count('l'))  # 3 统计字符串l出现的次数
print(res.count('l', 1, 10))  # 3 字符串l在索引1~9范围内出现的次数

# # 2.center,ljust, rjust, zfill
name = 'tony'
print(name.center(30, '-'))  # 总宽度为30，字符串居中显示，不够用-填充
#-------------tony - ------------
print(name.ljust(30, '*'))  # 总宽度为30，字符串左对齐显示，不够用*填充
#tony ** ** ** ** ** ** ** ** ** ** ** ** **
print(name.rjust(30, '*'))  # 总宽度为30，字符串右对齐显示，不够用*填充
#** ** ** ** ** ** ** ** ** ** ** ** ** tony
print(name.zfill(50))  # 总宽度为50，字符串右对齐显示，不够用0填充
#0000000000000000000000000000000000000000000000tony

# 3.expandtabs
name = 'hello\tworld'  # \t表示制表符(tab键)
print(name)  # hello    world
print(name.expandtabs(1))  # hello world (修改\t制表符代表的空格数)

# 4.captalize,swapcase,title
# # 4.1 captalize：首字母大写
username = 'my name is tony, my age is 18'
print(username.capitalize())  # My name is tony, my age is 18
# 4.2 swapcase：大小写翻转
mag = 'My name is Tony, my age Is 18'
print(mag.swapcase())  # mY NAME IS tONY, MY AGE iS 18
# 4.3 title：每个单词的首字母大写
res = 'my name is tony, my age is 18'
print(res.title())  # My Name Is Tony, My Age Is 18

# 5.is数字系列
# 在python3中
num1 = b'4'  # bytes
num2 = u'4'  # unicode,python3中无需加u就是unicode
num3 = '四'  # 中文数字
num4 = 'Ⅳ'  # 罗马数字

# isdigt:bytes,unicode
print(num1.isdigit())  # True
print(num2.isdigit())  # True
print(num3.isdigit())  # False
print(num4.isdigit())  # False

# isdecimal:uncicode(bytes类型无isdecimal方法)
print(num2.isdecimal())  # True
print(num3.isdecimal())  # False
print(num4.isdecimal())  # False

# isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
print(num2.isnumeric())  # True
print(num3.isnumeric())  # True
print(num4.isnumeric())  # True

# 三者不能判断浮点数
num5 = '4.3'
print(num5.isdigit())  # False
print(num5.isdecimal())  # False
print(num5.isnumeric())  # False
'''
# 总结:
#     最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
#     如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''

# 6.is其他
name = 'tony123'
print(name.isalnum())  # True(字符串中既可以包含数字也可以包含字母)
print(name.isalpha())  # False(字符串中只包含字母)
print(name.isidentifier())  # True
print(name.islower())  # True(字符串是否是纯小写)
print(name.isupper())  # False(字符串是否是纯大写)
print(name.isspace())  # False(字符串是否全是空格)
print(name.istitle())  # False(字符串中的单词首字母是否都是大写)

列表（list）

　　　1、类型转换

# 列表
num = '111, 222, 333'
print(type(num))    # <class 'str'>
num = list(num)
print(type(num))    # <class 'list'>
# 字典
num = {'k1': 111, 'k2': 222, 'k3': 333}
print(type(num))  # <class 'dict'>
num = list(num)
print(type(num))  # <class 'list'>
# 元组
num = (111, 222, 333)
print(type(num))  # <class 'tuple'>
num = list(num)
print(type(num))  # <class 'list'>
# 集合
num = {111, 222, 333}
print(type(num))  # <class 'set'>
num = list(num)
print(type(num))  # <class 'list'>

```list关键字可以将支付for循环的数据类型转换成列表```

　　2、使用

　　　　2.1、优先掌握的操作

# 1.按索引存取值(正向存取+反向存取)：即可存也可以取
# 1.1 正向取(从左往右)
l = [111, 222, 333, 444, 555]
print(l[2])  # 333
# 1.2 反向取(负号表示从右往左)
print(l[-1])  # 555
# 1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错
l[0] = 666
print(l)  # [666, 222, 333, 444, 555]

# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到3的元素
print(l[0:4])  # [111, 222, 333, 444]
# 2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
print(l[0:4:2])  # [111, 333]

# 3.长度
print(len(l))  # 5

# 4.成员运算in和not in
print(222 in l)  # True
print(777 not in l)  # True

# 5.添加
# 5.1 append()列表尾部追加元素
print(l.append(666))  # None
print(l)  # [111, 222, 333, 444, 555, 666]
# 5.2 append()一次性在列表尾部添加多个元素
print(l.append([777, 888, 999]))  # None
print(l)  # [111, 222, 333, 444, 555, [777, 888, 999]]
# 5.3 insert()在指定位置插入元素
print(l.insert(0, 999))  # None
print(l)  # [999, 111, 222, 333, 444, 555]
# 5.4 extend()一次性在列表尾部添加多个元素(相当于for循环+append操作)
print(l.extend([666, 777, 888]))  # None
print(l)  # [111, 222, 333, 444, 555, 666, 777, 888]

# 6.删除
# 6.1 del
print(l[0])  # 111 # 删除索引为0的元素
print(l)  # [111, 222, 333, 444, 555]
# 6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
print(l.pop())  # 555
print(l)  # [111, 222, 333, 444]
# 6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值
print(l.remove(111))  # None
print(l)  # [222, 333, 444, 555

　　　　2.2、列表的其他操作

# 1、reverse()
# 颠倒列表内元素顺序
l = [11, 22, 33, 44]
l.reverse()
print(l)  # [44, 33, 22, 11]

# 2.sort()给列表内所有元素排序
# 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
l = [11, 22, 3, 42, 7, 55]
l.sort()
print(l)  # [3, 7, 11, 22, 42, 55] 默认从小到大排序

l = [11, 22, 3, 42, 7, 55]
print(l.sort(reverse=True))  # None reverse用来指定是否颠倒排序，默认为False
print(l)  # [55, 42, 22, 11, 7, 3]

# 3、我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
l1 = [1, 2, 3]
l2 = [2, ]
print(l2 > l1)  # True
# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
s1 = 'hello'
s2 = 'ab'
print(s2 > s1)  # False 'h' > 'a'
# 所以我们也可以对下面这个列表排序
l = ['A', 'z', 'adjk', 'hello', 'hea']
l.sort()
print(l)  # ['A', 'adjk', 'hea', 'hello', 'z']

# 4、循环
# 循环遍历my_friends列表里面的值
l1 = [111, 222, 333, 444, 555]
for line in l1:
    print(line)
'''
111
222
333
444
555
'''

字典（dict）

　　　1、类型转换

# 转换1:
res = dict([['name', 'tony'], ('age', 18)])
print(res)  # {'name': 'tony', 'age': 18}

# 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
msg = {}.fromkeys(('name', 'age', 'sex'), [])
print(msg)  # {'name': [], 'age': [], 'sex': []}

　　2、使用

　　　　2.1、优先掌握的操作

# 1、按key存取值：可存可取
# 1.1 取
dic = {
    'name': 'tony',
    'age': 18,
    'hobbies': ['play game', 'read']
    }
print(dic['name'])  # tony
print(dic['hobbies'][1])  # read
# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value
dic['num'] = 123
print(dic)  # {'name': 'tony', 'age': 18, 'hobbies': ['play game', 'read'], 'num': 123}
# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
dic['name'] = 'tom'
print(dic)  # {'name': 'tom', 'age': 18, 'hobbies': ['play game', 'read'], 'num': 123}

# 2、长度len
print(len(dic))  # 3

# 3、成员运算in和not in
print('name' in dic)  # True 判断某个值是否是字典的key

# 4、删除
dic.pop('name')  # 通过指定字典的key来删除字典的键值对
print(dic)  # {'age': 18, 'hobbies': ['play game', 'read']}

# 5、键keys()，值values()，键值对items() 在python2中是列表 在python3中是迭代器
dic = {'age': 18, 'hobbies': ['play game', 'read'], 'name': 'zys'}
# # 获取字典所有的key  获取字典所有的键 看成列表即可
print(dic.keys())  # dict_keys(['age', 'hobbies', 'name'])
# # 获取字典所有的value 获取字典所有的值 看成列表即可
print(dic.values())  # dict_values([18, ['play game', 'read'], 'zys'])
# # 获取字典所有的键值对  获取字典里面所有的键值对 组织成列表套元组的形式 元组内有两个元素 第一个是k第二个是v
print(dic.items())  # dict_items([('age', 18), ('hobbies', ['play game', 'read']), ('name', 'zys')])


# 6、循环
# 6.1 默认遍历的是字典的key
for key in dic:
    print(key)
'''
age
hobbies
name
'''
# 6.2 只遍历key
for key in dic.keys():
    print(key)
'''
age
hobbies
name
'''
# 6.3 只遍历value
for key in dic.values():
    print(key)
'''
18
['play game', 'read']
zys
'''
# 6.4 遍历key与value
for key in dic.items():
    print(key)
'''
('age', 18)
('hobbies', ['play game', 'read'])
('name', 'zys')
'''

　　　2.2、需要掌握的操作

　　　　get（）

dic = {'k1': 'tony', 'k2': 'Tony', 'k3': 'JY'}
print(dic.get('k1'))  # tony  key存在，则获取key对应的value值
res = dic.get('xxx')
print(res)  # # None key不存在，不会报错而是默认返回None

res = dic.get('xxx', 666)  # key不存在时，可以设置默认返回的值
print(res)  # 666  key不存在时，可以设置默认返回的值
# ps:字典取值建议使用get方法

　　pop（）

dic = {'k1': 'tom', 'k2': 'Tony', 'k3': 'JY'}
v = dic.pop('k2')  # 删除指定的key对应的键值对,并返回值
print(dic)  # {'k1': 'tom', 'k3': 'JY'}
print(v)  # Tony

　　popitem（）

dic = {'k1': 'tom', 'k2': 'Tony', 'k3': 'JY'}
item = dic.popitem()  # 随机删除一组键值对,并将删除的键值放到元组内返回
print(dic)  # {'k1': 'tom', 'k2': 'Tony'}
print(item)  # ('k3', 'JY')

　　update（)

# 用新字典更新旧字典，有则修改，无则添加
dic = {'k1': 'tom', 'k2': 'Tony', 'k3': 'JY'}
dic.update({'k1': 'JN', 'k4': 'js'})
print(dic)  # {'k1': 'JN', 'k2': 'Tony', 'k3': 'JY', 'k4': 'js'}

　　fromkeys（）

dic = dict.fromkeys(['k1', 'k2', 'k3'], [])
print(dic)  # {'k1': [], 'k2': [], 'k3': []}
初始化字典

　　setdefault（）

dic = dict.fromkeys(['k1', 'k2', 'k3'], [])
print(dic)  # {'k1': [], 'k2': [], 'k3': []}
# # key不存在则新增键值对，并将新增的value返回
dic = {'k1': 111, 'k2': 222}
res = dic.setdefault('k3', 333)
print(res)  # 333
print(dic)  # {'k1': 111, 'k2': 222, 'k3': 333} 字典中新增了键值对

# key存在则不做任何修改，并返回已存在key对应的value值
dic = {'k1': 111, 'k2': 222}
res = dic.setdefault('k1', 666)
print(res)  # 111
print(dic)  # {'k1': 111, 'k2': 222}字典不变

　　　习题

res = dict.fromkeys(['k1', 'k2', 'k3'], [])
res['k1'].append(111)
res['k2'].append(222)
res['k3'].append(333)
print(res)  # {'k1': [111, 222, 333], 'k2': [111, 222, 333], 'k3': [111, 222, 333]}
res['k1'] = [111, 222, 333]
print(res)  # {'k1': [111, 222, 333], 'k2': [], 'k3': []}
res['k1'].append(444)
print(res)  # {'k1': [111, 222, 333, 444], 'k2': [], 'k3': []}
dic = {'age': 18, 'name': 'tony'}
print(dic.setdefault('name','tony123'))  # tony
# 当键存在的情况下 不修改而是获取该键对应的值
print(dic)  # {'age': 18, 'name': 'tony'}
# 当键不存在的情况下 新增一组键值对 并且该方法的结果是新增的值
print(dic.setdefault('pwd', '123'))  # 123
print(dic)  # {'age': 18, 'name': 'tony', 'pwd': '123'}

元组（tuple）

　　1、类型转换

# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')
print(tuple([1, 2, 3]))  # (1, 2, 3)
print(tuple({"name": "tony", "age": 18}))  # ('name', 'age')
print(tuple((1, 2, 3)))  # (1, 2, 3)
print(tuple({1, 2, 3, 4}))  # (1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

　　2、使用

tuple1 = (1, 'tony', 18.0, 11, 22, 33)
# # 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！
# print(tuple1[0])  # 1
# print(tuple1[-2])  # 22
# print(tuple1[0]) = 'tony'  # 报错：TypeError:

# 2、切片(顾头不顾尾，步长)
# print(tuple1[0:6:2])  # (1, 18.0, 22)

# 3、长度
# print(len(tuple1))  # 6

# 4、成员运算 in 和 not in
# print('tony' in tuple1)  # True
# print('tony' not in tuple1)  # False

# 5、循环
for line in tuple1:
     print(line)
'''
1
tony
18.0
# 11
# 22
# 33
'''

　　3、习题

# 1、
# t1 = (111)  # 整型
# t2 = (11.11)  # 浮点型
# t3 = ('hello')  # 字符串
'''元组哪怕内部只有一个元素 也需要加上逗号'''
print(type((111,)))  # <class 'tuple'>
'''容器类型:内部可以存放多个值的数据类型都可以称之为容器类型
    建议:所有的容器类型在存储数据的时候 如果内部只有一个元素 
        那么也推荐你加上逗号'''
# 2、
t1 = (111, 222, [11, 22, 33])
t1[2].append(44)
print(t1)  # (111, 222, [11, 22, 33, 44])

集合（set）

　　1、类型转换

# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
s = set([1, 2, 3, 4])
print(s)  # {1, 2, 3, 4}
s1 = set((11, 22, 33, 44))
print(s1)  # {33, 11, 44, 22}
s2 = set({'name': 'tony', })
print(s2)  # {'name'}
s3 = set('tony')
print(s3)  # {'y', 'n', 'o', 't'}

　　2、使用

　　　　2.1、去重

# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序
# s1 = {1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5}
# print(s1)  # {1, 2, 3, 4, 5}
name_list = ['kevin', 'tony', 'tony', 'tony', 'kevin', 'kevin']
# 1.先将列表转换成集合
s1 = set(name_list)
# 2.再将去重之后的集合转换成列表
l1 = list(s1)
print(l1)  # ['kevin', 'tony']
"""练习"""
ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
# 基本要求:去重即可
s1 = set(ll)
ll1 = list(s1)
print(ll1)

# 拔高要求:去重并保留原来的顺序
# 1.先定义一个新列表
new_list = []
# # 2.for循环ll列表
for i in ll:
    # 3.判断当前元素是否在新列表中
    if i not in new_list:
        # 3.1 如果不在 则添加到新列表
        new_list.append(i)
    # 3.2 如果在 则不管
print(new_list)

　　　　2.2、关系运算

friends1 = {"zero", "kevin", "tony", "tom"}  # 用户1的好友们
friends2 = {"Jy", "ricky", "tony", "tom"}  # 用户2的好友们
# 1.求两个用户的共同好友
print(friends1 & friends2)  # {'tom', 'tony'}
# 2.求两个用户所有的好友
print(friends1 | friends2)  # {'zero', 'Jy', 'tom', 'tony', 'ricky', 'kevin'}
# 3.求用户1独有的好友
print(friends1 - friends2)  # {'zero', 'kevin'}
# 4.求用户2独有的好友
print(friends2 - friends1)  # {'ricky', 'Jy'}
# 5.求用户1和用户2各自的好友
print(friends1 ^ friends2)  # {'ricky', 'kevin', 'zero', 'Jy'}
# 6.父集与子集
s1 = {11, 22, 33, }
s2 = {11, 33}
print(s1 > s2)  # 判断s1是否是s2的父集   True
print(s2 < s1)  # 判断s2是否是s1的子集   True

　　　　2.3、其他操作

# 1.长度
s = {'a', 'b', 'c'}
print(len(s))  # 3

# 2.成员运算
print('c' in s)  # True

# 3.循环
for item in s:
    print(item)
'''
b
c
a
'''

 可变与不可变类型

　　可变数据类型：值发生改变时，内存地址不变，即id不变，证明在改变原值

　　不可变类型：值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值

　　整型（不可变类型）

x = 18
print(id(x))  # 1772646400
x = 19
print(id(x))  # 1772646432
# 值发生改变，内存地址也改变，说明整型是不可变类型

　　浮点型（不可变类型）

x = 18.1
print(id(x))  # 1749208338792
x = 19.1
print(id(x))  # 1749208338816
# 值发生改变，内存地址也改变，说明浮点型是不可变类型

　　字符串（不可变类型）

name = 'tony'
print(id(name))  # 1835067818592
name = 'tom'
print(id(name))  # 1835067818760
# 值发生改变，内存地址也改变，说明字符串是不可变类型

　　列表（可变类型）

num = [111, 222, 333]
print(id(num))  # 2301638293384
num[0] = 555
print(id(num))  # 2301638293384
print(num.append(666))  # None
print(id(num))  # 2301638293384
# 值发生改变，内存地址没变。说明列表是可变类型

　　字典（可变类型）

d = {'k': 111, 'k1': 222, 'k3': 333}
print(id(d))  # 1914058780392
d['k'] = 555  # 1914058780392
print(id(d))
# 值发生变化，内存地址没变。说明字典事可变类型