004 Python数据类型

• l = [1, 2, 3, 4, 5, 6]
  # 正向步长
  print(l[0:3:1])
  # 反向步长
  print(l[2::-1])
  
  # 通过索引取值实现列表翻转
  print(l[::-1])

  int

# int可以将纯整数构成的字符串转换成整型，若包含其它非整数符号则会报错
s = '123'
res = int(s)
print(res, type(res))

# s = '12.3'
# res = int(s)
# print(res, type(s))

# 十进制与其它进制之间的相互转换
# 十进制转其它进制
print(bin(3))  # 0b11
print(oct(9))  # 0o11
print(hex(17))  # 0x11

# 其它进制转十进制
print(int('0b11', 2))
print(int('0o11', 8))
print(int('0x11', 16))

# float同样可以用来做数据类型转换
s = '12.3'
res = float(s)
print(res, type(res))

• str

# 字符串的定义：用单引号''，双引号""，三引号""""""引起来的内容
name1 = 'jack'
name2 = "Bob"
name3 = """我们是一家人"""

name4 = '''我们都有一个家，名字叫中国'''

print(name1, name2, name3, name4)

# 字符串的数据类型转换：任何类型都可以转成字符串，格式：str(任意类型数据)
# 字典和集合都是用{}大括号括起来的
# 列表
print(str([1, 2, 3]))
# 字典
print(str({'name': 'egon', 'age': 18}))
# 元组
print(str((1, 2, 3)))
# 集合
print(str({1, 2, 3, 4}))

# 字符串的使用：
# 字符串按索引取值

str1 = 'hello Python hello Java'
# 正向取值
print(str1[6])  # P

# 反向取值
print(str1[-2])  # 0

# 字符串不支持按照索引去修改
# str1[5] = 'X'  # 报错'str' object does not support item assignment

# 字符串切片（顾头不顾尾，步长）

# 正向切
print(str1[0:9])
# 正向切+步长
print(str1[0:9:2])
# 反向切
print(str1[-4:-1])  # 顾头不顾尾，所以娶不到第四个
# 反向切+步长
print(str1[::-1])  # avaJ olleh nohtyP olleh
print(str1[:5:-1])  # avaJ olleh nohtyP
print(str1[:6:-1])  # avaJ olleh nohty
print(str1[5::-1])  # olleh
print(str1[6::-1])  # P olleh

# 获取字符串长度即字符的个数（但凡存在于引号内的都算作字符）
print(len(str1))  # 23

# 成员运算
print('hello' in str1)
print('hi' not in str1)

# 移除字符串内首尾制定的字符（默认移除空格）
str2 = '  Life is short  '
print(str2.strip())  # Life is short
str3 = '***Life is short ***'
print(str3.strip('*'))

# 切分split（默认切分是按照空格来切分），切割完是一个列表list
print('hello world'.split())
print('127.0.0.1'.split('.'))
'hello world'.split()

# 循环取出字符串中的字符
str4 = '今天你要嫁给我吗？今天你要嫁给我吗？'

for x in str4:
    print(x)

# strip(),lstrip(),rstrip()
# strip()：移除字符串左右两边的字符，默认移除空格，可加参数，左右两边有多少移除多少
# lstrip()：移除字符串左边的字符，默认移除空格
# rstrip()：移除字符串右边的字符，默认移除空格
str5 = '&&&hello world&&&'
print(str5.strip('&'))
print(str5.rstrip('&'))
print(str5.lstrip('&'))

# lower()，upper()
# lower()：将字符串中的所有字符转换成小写
# upper()：将字符串中的所有字符转换成大写
str6 = 'My name is Bob'
print(str6.upper())
print(str6.lower())

# stratwith():判断字符串是否以括号内的字符串开始
# endwith()：判断字符串是否以括号内的字符串结束
str7 = 'hello world'
print(str7.startswith('h'))
print(str7.startswith('hello'))
print(str7.startswith('world'))

print(str7.endswith('d'))
print(str7.endswith('world'))
print(str7.endswith('hello'))

# 字符串的格式化输出:format
print('my name is {name}, my age is {age}'.format(name='lijipeng', age=18))
print('my name is {name}, my age is {name}'.format(name='lijipeng', age=18))
# print('my name is {name}, my age is {age}'.format(name='lijipeng')) #字符串中的age没有被赋值，报错

# format的其它用法1类似于%s，按位置给值
print('my name is {}，my age is {}'.format('lijipeng', 18))

# format的其它用法2：将format中的参照看成一个列表，然后按照{索引取值}
print('my name is {0}, my age is {1}'.format('lijipeng', 18))
print('my name is {0}, my age is {0}'.format('lijipeng', 18))
print('my name is {1}, my age is {0}'.format('lijipeng', 18))

# split，rsplit（默认是从左边切）
print('127.0.0.1'.split('.', 1))
print('127.0.0.1'.rsplit('.', 3))
print('127.0.0.1'.rsplit('.', 4))  # 只能切三次，但是切了四次也不会报错

# join 从可迭代的对象中取出多个字符串，然后按照指定的分隔符进行拼接
# join前是拼接符号 '%' '|' '&&&'是一个字符串
# join后是字符串列表 'hello world' ['1','2','3'] ['a','b','c']
print('%'.join('hello world'))
print('|'.join(['1', '2', '3']))
print('&&&'.join(['a', 'b', 'c']))

# replace(可以部分也可以全部替换) 用新的字符串替换旧的字符串从而形成一个新的字符串
# 替换的是字符串里面的某些字符，old和new都应该是字符串
str8 = 'my name is jack, my age is 18!'
print(str8.replace('18', '73'))
print(str8.replace('my', 'MY', 1))
print(str8.replace('my', 'MY', 2))

# isdigit：判断字符串中是否由纯数字组成
str9 = '123456789'
str10 = '12345g678910'
print(str9.isdigit())
print(str10.isdigit())

# 了解操作
# find rfind index rindex count
# find 从指定范围内查找子字符串的起始索引，找到返回起始索引，找不到返回-1

print('hello world'.find('he', 0, 10))
print('hello world'.find('he', 1, 10))
print('hello world'.find('o', 1, 10))

# rfind 从指定范围内查找子字符串的起始索引，找到返回起始索引，找不到返回-1
print('hello world'.rfind('he'))
print('hello world'.rfind('l'))
print('hello world'.rfind('ll'))
print('hello world'.rfind('lll'))

# index 从指定范围内查找子字符串的起始索引，找到返回起始索引，找不到报错
print('hello world'.index('he'))
# print('hello world'.index('he', 1, 10)) #会报错
# print('hello world'.index('ll', 1, 3))  # 会报错，因为取不到3索引
print('hello world'.index('ll', 1, 4))  # 不会报错，可以取到4索引

# rindex 从指定范围内查找子字符串的起始索引，找到返回起始索引，找不到报错
print('hello world'.rindex('l'))
# print('hello world'.rindex('l',10,11)) #

# count：统计字符串在大字符串中出现的次数
print('hello world'.count('l'))  # 3
print('hello world'.count('l', 1, 5))  # 2
print('hello world'.count('ll'))  # 1
print('hello world'.count('lll'))  # 0

# center,ljust,rjust,zfill

# center：字符串居中操作
# __width第一个参数为返回字符串的总长度
# __filechar第二个参数为不够用什么字符来填充
# 本身字符串的长度已经超过了__width，则直接展示本身即可
print('lijipeng'.center(30, '-'))  # -----------lijipeng-----------
print('lijipenglijipenglijipenglijipenglijipenglijipenglijipenglijipenglijipeng'.center(30, '-'))

# ljust：字符串左对齐展示，不够的用__filechar填充，本身字符串的长度已经超过了__width，则直接展示本身即可
print('lijipeng'.ljust(30, '-'))
# rjust：字符串右对齐展示，不够的用__filechar填充，本身字符串的长度已经超过了__width，则直接展示本身即可
print('lijipeng'.rjust(30, '-'))
print('lijipenglijipenglijipenglijipenglijipenglijipenglijipenglijipenglijipeng'.ljust(30, '-'))
print('lijipenglijipenglijipenglijipenglijipenglijipenglijipenglijipenglijipeng'.rjust(30, '-'))

# zfill:字符串右对齐展示，不够的用0补充，本身字符串的长度已经超过了__width，则直接展示本身即可
print('lijipeng'.zfill(50))
print('lijipenglijipenglijipenglijipenglijipenglijipenglijipenglijipenglijipeng'.zfill(30))

# expandtabs：修改制表符代表的空格数
str11 = 'lijipeng\tworld'
print(str11)
print('lijipeng\tworld'.expandtabs(1))
print('lijipeng\tworld'.expandtabs(2))
print('lijipeng\tworld'.expandtabs(4))
print('lijipeng\tworld'.expandtabs(5))
print('lijipeng\tworld'.expandtabs(6))

# expitalize,swapcase,title
# expitalize：首字母大写,本身字符串就是大写的话返回原来的字符串
print('hello world'.capitalize())
print('Hello world'.capitalize())

# swapcase：大小写翻转
print('My name is lijipeng, My age is 18'.swapcase())

# title：单词首字母大写
print('My name is lijipeng,My age is 18'.title())

# is数字系列
# 数字的四种格式：bytes，unicode，中文数字，罗马数字
num1 = b'1'
num2 = u'1'
num3 = '一'
num4 = 'I'
# isdigit:
# 用法1：判断单个字符是否为数字
# 用法2：判断字符串是否全部由数字组成
print(num1.isdigit())  # True
print(num2.isdigit())  # True
print(num3.isdigit())  # False
print(num4.isdigit())  # False

# isdecimal
# 用法：用来检查字符串中的所有字符是否都是十进制数字字符
print(num1.isdigit())  # bytes类型的数字没有isdecimal方法
print(num2.isdecimal())  # True
print(num3.isdecimal())  # False
print(num4.isdecimal())  # False

# isnumeric:用来检查字符串是否只包含数字字符
print(num1.isdigit())
print(num2.isnumeric())  # True
print(num3.isnumeric())  # True
print(num4.isnumeric())  # False

# 总结：最常用的就是isdigit，可以判断bytes和unicode类型，如果要判断中文数字或罗马数字则需要使用isnumeric

# is其它
name = 'tony123'
# isalnum：字符串中既可以包含数字也可以包含字母
print(name.isalnum())
# isalpha：字符串中只包含字母
print(name.isalpha())
# isidentifier：用来判断字符串中是否是合法的标识符
name1 = 'tony123_'
name2 = 'tony123_$'
name3 = 'print'
name4 = '123tony'
print(name1.isidentifier())
print(name2.isidentifier())
print(name3.isidentifier())
print(name4.isidentifier())

# islower：判断字符串中是否都是纯小写
# isupper：判断字符串中是否都是纯大写
print('my name is lijipeng'.islower())
print('my name is lijipeng'.isupper())
print('my name is LIJIPENG'.isupper())
print('my name is LIJIPENG'.isupper())
print('MY NMAE IS LIJIPENG'.isupper())

# isspace：判断字符串中是否全是空格
print('     '.isspace())  # True
print('  womenshi   '.isspace())  # False
print('\t'.isspace())  # True

# istitle:判断字符串中单词首字母是否是大写
print('My Name Is Ljipeng'.istitle())
print('my Name Is hhaha'.istitle())

 

# 列表定义：在[]内，用逗号分隔开多个任意数据类型的值

l1 = [1, 'test', [2, 3]]  # 本质就是l1 = list([1, 'test', [2, 3]])

# 列表类型转换
# 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型
# list()会跟for循环一样，遍历出数据类型中包含的每一个元素，然后放到列表中

print(list('hello world'))  # 字符串类型数据'hello world'可以被for循环遍历，所以可以传给list()转换成列表类型，print打印列表则会展示一个字符列表
print(list([1, 2, 3]))  # 通过list()转化后打印列表 [1, 2, 3]
print([1, 2, 3])  # 直接打印列表 [1, 2, 3]
print(list({'name': 'egon',
            'age': 18}))  # 字典{'name':'egon','age':18}可以被for循环遍历，遍历得到的是key值，所以可以传给list()转换成列表类型，print打印列表则会展示一个key的列表
print(list((1, 2, 3)))  # 元组(1, 2, 3)也可以被for循环遍历，所以可以传给list()转换成列表类型，print打印列表展示[1, 2, 3]
print(list({1, 2, 3, 4}))  # 集合{1, 2, 3, 4}可以被for循环遍历，所以可以传给list()转换成列表类型，print打印列表展示[1, 2, 3, 4]

# 列表按索引取值
hobbies = ['basketball', 'football', 'sing']
print(hobbies[0])  # basketball 正向取值
print(hobbies[-1])  # sing 反向取值

# 列表按照索引修改指定位置的值，索引不存在则会报错list assignment index out of range
hobbies[1] = 'read'
print(hobbies)
# hobbies[3] = 'test' # 列表有三个值，索引最大到2，所以会报错

# 列表切片
# 顾头不顾尾：取出索引0-2的元素
print(hobbies[0:2])  # 取不到2
print(hobbies[0:3])
# 步长
print(hobbies[0:3:2])  # ['basketball', 'sing'] 这里的2指的是步长，首次取0索引，第二次取2索引

# 列表长度len
print(len(hobbies))

# 成员运算 in not in
print('basketball' in hobbies)
print('sing' not in hobbies)

# 添加元素
# 尾部追加元素append
hobbies.append('sleep')  # 在列表尾部追加'sleep'元素
print(hobbies)

# 一次性在尾部添加多个元素extend,括号内应该是一个列表
hobbies.extend(['eat', 'movies'])
print(hobbies)

# 在指定位置插入元素insert，如果输入的索引超过了本身的最大索引，则会默认加在最后面
hobbies.insert(0, 'heihei')
hobbies.insert(7, 'haha')
hobbies.insert(10, 'xixi')
hobbies.insert(-2, '666')
print(hobbies)

# 删除元素
# del listname[索引值] 删除指定索引的值,没有返回值，如果该索引值不存在，则会报错list assignment index out of range
del hobbies[0]
print(hobbies)

del hobbies[1]
# del hobbies[10] # 报错
print(hobbies)

# listname.pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以指定索引值来删除对应的元素
print(hobbies.pop())
print(hobbies)

print(hobbies.pop(2))
print(hobbies)

# remove()括号内指名道姓要删除某个元素，返回值为None
print(hobbies.remove('sing'))
print(hobbies)

# reverse() 颠倒列表内元素顺序，返回值为None
print(hobbies.reverse())
print(hobbies)
# sort() 给列表内所有元素排序,返回值为None,reverse默认值为False，从小到大排序
print(hobbies.sort())
print(hobbies)
print(hobbies.sort(reverse=False))
print(hobbies)
print(hobbies.sort(reverse=True))
print(hobbies)

# 数字可以直接比较大小，字符串、列表也可以比较大小，原理相同都是比较相同位置的元素的大小，如果分出大小，则无需比较下一个元素
print([1, 2, 3] < [2]) #True
print('abc' < 'ABC') #False

# for循环遍历列表中的值
for x in hobbies:
    print(x)

 

l = [1, 2, 3, 4, 5, 6]
# 正向步长
print(l[0:3:1])
# 反向步长
print(l[2::-1])

# 通过索引取值实现列表翻转
print(l[::-1])

 

# 元组作用：元组和列表相似，也可以存多个任意类型的数据，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用来记录多个固定不允许修改的值，单纯只是为了取
# 元组其实就是一个元素不可变的列表，只能用来取，元素不可更改。

# 元组定义，如果元组内只有一个值，则必须得有一个逗号，否则()就只是包含的意思，而非定义元组
countries = ('中国', '美国', '英国')  # 本质就是tuple('中国','美国','英国')
tests = ('数学')  # 元组中只有一个值，必须得有逗号，不然就是包含的意思
tests1 = (1,)
print(countries, type(countries))
print(tests, type(tests))  # 数学 <class 'str'>
print(tests1, type(tests1))  # (1,) <class 'tuple'>

# 类型转换：但凡能被for循环遍历的数据类型都可以传给tuple()转换成元组类型

print(tuple('hello world'))  # 字符串
print(tuple([1, 2, 3]))  # 列表
print(tuple({'name': 'egon', 'age': 18}))  # 字典('name', 'age')
print(tuple((1, 2, 3)))  # 元组
print(tuple({1, 2, 3, 4}))  # 集合

# tuple()会跟for循环一样，遍历出数据类型中包含的每一个元素，然后放在元组中

# 元组使用

tuple1 = (1, 2, 3, 'hello', 23.4, [1, 2], {'name': 'egon', 'age': 18})
# 按索引取值,只能取，不能改，改的话会报错
print(tuple1[0])
print(tuple1[1])
print(tuple1[2])
print(tuple1[3])
print(tuple1[4])
print(tuple1[5])
print(tuple1[6])

print(tuple1[-1])
# tuple1[2] = '' #报错
# 切片
print(tuple1[0:3:1])
# 长度
print(len(tuple1))
# 成员运算
print(1 in tuple1)
print('helloworld' in tuple1)
# 循环
for tup in tuple1:
    print(tup)

•  dict

# 字典的定义方式
# 在{}内用逗号分隔开的多个元素，每个元素都是key:value的形式，value可以是任意数据类型，而key则必须是不可变类型，通常key是str类型，因为str类型对value有描述性功能。
# 字典定义格式1
info = {'name': 'jack', 'age': 18, 'salary': 20000.4}  # 本质是dict({'name':'jack','age':18,'salary':20000.4})
# 字典定义格式2:就是将{}换成了()，前面加了dict转换，()内格式为key=value中间用逗号隔开
# 前面需要用dict强转在()内用逗号分隔开的多个元素，每个元素都是key=value的形式，value可以是任意数据类型，而key则必须是不可变类型，通常key是str类型，因为str类型可以对value有描述性功能。
info = dict(name='jack', age=18, salary=20000.4)
# 字典类型转换
# 转换1:通过dict()的形式强制类型转换，()内是一个列表，列表内每个元素都是一个列表，格式为key,value
info1 = dict([['name', 'tony'], ['age', 18]])
print(info1)

# 转换2：通过调用空字典{}的frromkeys方法，相当于是初始化了字典的key,value的初始化还得通过赋值操作
# 参数1是一个key的元组
# 参数2是一个value值，
info2 = {}.fromkeys(('name', 'age', 'sex'), None)
info['name'] = 'jack'
info['age'] = 18
info['sex'] = 'male'
print(info2)
# 字典使用

# 按key取值
dict1 = {'name': 'jack',
         'age': 19,
         'hobbies': ['basketball', 'football']}

print(dict1['name'])
print(dict1['hobbies'][0])

# 赋值操作
# 如果key不存在于字典中，则会新加key:value
dict1['height'] = 181.5  # key不存在就新加一个key:value
dict1['name'] = 'Bob'  # key存在就修改原来的值
print(dict1)

# 统计字典长度，这里统计的是key的个数
print(len(dict1))

# 成员运算in not in
# 判断某个值是否是该字典的key
print('name' in dict1)
print('gender' in dict1)
print('name' not in dict1)
print('gender' not in dict1)

# 字典的删除pop
# 通过指定字典的key来删除key对应的键值对
# 返回值为所删除key对应的value值
print(dict1.pop('height'))
print(dict1)

# 获取字典所有的key，所有的value，所有的键值对
# 获取所有的key，方式字典名.keys
# 返回值是一个被dict_keys强制转换的列表
print(dict1.keys())  # dict_keys(['name', 'age', 'hobbies'])

# for 循环遍历所有的key
for key in dict1.keys():
    print(key)

# 获取字典所有的value，方式：字典名.values
# 返回值是一个被dict_values强制转换的列表
print(dict1.values())  # dict_values(['Bob', 19, ['basketball', 'football']])

# for 循环遍历所有的value
for value in dict1.values():
    print(value)

# 获取字典所有的键值对，方式：字典名.items
# 返回值是一个被dict_items强制转换的列表，列表中每个元素都是一个元组，元组内一个是key，一个是value
print(dict1.items())  # dict_items([('name', 'Bob'), ('age', 19), ('hobbies', ['basketball', 'football'])])

for item in dict1.items():
    print(item[0])
    print(item[1])

# get()
# 通过key来取值
# key存在则获取key对应的value值
# 字典取值建议使用get方法
print(dict1.get('name'))
print(dict1.get('age'))
print(dict1.get('hobbies'))
# key不存在则返回None
print(dict1.get('gender'))
# key不存在也可以返回默认值
print(dict1.get('gender', 'male'))

# pop删除元素上面已经演示过了
# popitem()，只要执行一次就会随机删除一次
# 随机删除一个键值对，并将删除的键值放在元组中返回
print(dict1)
# print(dict1.popitem()[0],dict1.popitem()[1]) # 首次删除删除的是hobbies对应的键值对，第二次删除删除的是age对应的键值对hobbies 19
# print(dict1.popitem()[1])

for item in dict1.popitem():
    print(item)
    print(item[0])
    print(item[1])

# update
# 用新字典更新旧字典，有则改之，无则添加。定义方式：原字典名.update()()内是一个字典

print(dict1)
dict1.update({'name': 'jack', 'gender': 'male', 'hobbies': ['basketball', 'football']})
print(dict1)

# fromkeys
# 必须得有一个键的列表集合，不然报错
dic = dict1.fromkeys(['key'])
print(dic)

# setdefault
# 格式：
# 当key不存在时，则新增键值对，默认加在最后，并将键值对的value值返回
print(dict1.setdefault('salary', 10000.3))  # 10000.3
print(dict1)

# 当key存在时，则原字典不改变，返回值为键对应的value值
print(dict1.setdefault('name', 'NIUPI'))  # jack

•  list

# 集合作用： list tuple dict 都可以存放多个值，但是集合主要是用来去重和关系运算

# 集合定义：在{}内用逗号分隔开的多个元素

# 集合特点：
# 1、集合内的每个元素都是不可变类型
# 2、集合内的元素是不可以重复的
# 3、集合内的元素是无序的，也就是不可以通过索引取值

s1 = {1, 2, 3, 4}  # 本质是s1 = set({1,2,3,4})
print(s1)
s1 = set({1, 2, 3, 4})
print(s1)
# print(s1[0]) # 是不可以通过下标访问的，会报错TypeError: 'set' object is not subscriptable

# 对于列表、元组类型来说是索引对应值，对于字典来说是key对应值，都可以取到对应的单个值。而集合类型没有索引也没有key与值对应，所以无法取到单个值

# 集合主要是用来去重和关系运算，没有取出单个值的需求。

# {}既可以用来定义字典也可以用来定义集合，字典{}内是key:value的格式，如果定义一个空字典和空集合
s2 = {}  # 定义空字典
s3 = set()  # 定义空集合
print(s2, type(s2))
print(s3, type(s3))

# 列表类型转换
# 但凡能被for循环遍历的数据类型都可以传给set()转换成集合类型
# 强调：for循环遍历出的每个元素必须是不可变类型

s1 = set([1, 2, 3, 4])  # 列表
s2 = set((1, 2, 3, 4))  # 元组
s3 = set('hello world')  # 字符串
s4 = set({'name': 'egon', 'age': 18})  # 字典

print(s1, type(s1))
print(s2, type(s2))
print(s3, type(s3))
print(s4, type(s4))

# 关系运算

num1 = {1, 2, 3, 4}
num2 = {5, 6, 3, 4}

# 一个集合包含num1和num2的所有数字(合集/并集)
num3 = num1 | num2
print(num3)

# 求两个数字集合的共同数字（交集）
num4 = num1 & num2
print(num4)

# 求num1独有的数字（差集）
num5 = num1 - num2
print(num5)

# 求num2独有的数字（差集）
num6 = num2 - num1
print(num6)

# 求两个用户独有的好友们（对称差集）
num7 = num1 ^ num2
print(num7)
num7 = num1 - num2 | num2 - num1
print(num7)

# 判断两个集合是否相同
print(num1 == num2)
print({1, 2, 3} == {1, 2, 3})

# 一个集合是否包含另外一个集合（父集）
print({1, 2, 3} > {2, 3})  # True
print({1, 2, 3, 4} > {1, 2, 3, 4, 5})  # False
print({1, 2, 3} >= {1, 2, 3})

# 一个集合是否是另一个集合的子集（子集）
print({1, 2, 3} <= {1, 2, 3})
print({1, 2, 3} < {1, 2, 3})
print({1, 2, 3} <= {1, 2})

# 去重
# 集合去重有局限性
# 只能针对不可变类型
# 集合本身是无序的，去重之后无法保留原来的顺序

l = ['a', 'b', 1, 'a', 'a']
# s = set(l)
# # 集合本身是无序的
# print(s)
# l = list(s)
# print(l)  # 返回给列表时无法保证原来的顺序

# 通过代码实现列表去重后保证了原来的顺序
new_l = []
for temp in l:
    if temp not in new_l:
        new_l.append(temp)

print(new_l)

# 不可以通过代码实现元组去重，因为本身元组内的元素值就是不可改变的
tup = (1, 2, 3, 1, 2, 4)
s = set(tup)
new_tup = list(s)
print(new_tup)

# 通过代码实现字符串内字符去重
str1 = 'hello world'
new_str1 = ''

for s in str1:
    if s not in new_str1:
        new_str1 += s

print(new_str1)

# 通过代码实现字典内重复数据去重
dict1 = [{'name': 'egon', 'age': 18, 'gender': 'male'},
         {'name': 'alex', 'age': 73, 'gender': 'fmale'},
         {'name': 'Bob', 'age': 57, 'gender': 'male'},
         {'name': 'egon', 'age': 18, 'gender': 'male'},
         {'name': 'egon', 'age': 18, 'gender': 'male'}]

# new_dict1 = set(dict1) # 列表中的每个元素是字典，是可变类型，是不可哈希的，所以会报错，只能通过代码形式去重
new_dict1 = []
for d in dict1:
    if d not in new_dict1:
        new_dict1.append(d)
print(
    new_dict1)  # [{'name': 'egon', 'age': 18, 'gender': 'male'}, {'name': 'alex', 'age': 73, 'gender': 'fmale'},
# {'name': 'Bob', 'age': 57, 'gender': 'male'}]

# 既去除了重复又保证了顺序

# 集合长度
print(len(new_dict1))

# 关系运算，判断一个元素是否在该集合中
print({'name': 'egon', 'age': 18, 'gender': 'male'} in new_dict1)
print({'name': 'egon1', 'age': 18, 'gender': 'male'} in new_dict1)

# 集合的循环
for i in new_dict1:
    print(i)

"""
一.关系运算
　　有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'jason','egon','kevin','ricky','gangdan','biubiu'}
　　linuxs={'kermit','tony','gangdan'}
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合
"""
pythons = {'jason', 'egon', 'kevin', 'ricky', 'gangdan', 'biubiu'}
linuxs = {'kermit', 'tony', 'gangdan'}
# 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
# 求出所有报名的学生名字集合
print(pythons | linuxs)
# 求出只报名python课程的学员名字
print(pythons - linuxs)
# 求出没有同时报这两门课程的学员名字集合
print(pythons ^ linuxs)

# 可变类型与不可变类型
# 可变类型：值发生改变时，内存地址没变，即id没变，证明了就是在改原值
# 不可变类型：值发生改变时，内存地址也变了，即id也变了，证明了不是在改原值，而是重新创建了一个值

# 数字类型是不可变类型
x = 10
print(id(x))  # 1470562435600
x = 20
print(id(x))  # 1470562435920

# 上述现象表明值发生改变了，x的值从10变成20，但是id也变了，也就是用的不是同一块内存空间，即产生了新的值，所以数字类型是不可变类型

str1 = 'hello'
print(id(str1))  # 2291141388272
str1 = 'world'
print(id(str1))  # 2291141388400

# st1的值从'hello'变成了'world'，但是id也变了，也就是用的不是同一块内存空间，即产生了新值，所以字符串类型也是不可变类型

list1 = ['tom', 'jack', 'anne']
print(id(list1))  # 3091933207936
list1 = ['tom1', 'jack1', 'anne1']  # 这相当于是重新创建了一个集合
print(id(list1))  # 3091933452736

# list1的值从['tom', 'jack', 'anne']变成了['tom1', 'jack1', 'anne1']，但是id也变了，也就是用的不是同一块内存空间，即产生了新值，
# 所以针对列表本身它其实是不可变类型

# 列表内元素'haha'变成了'niubi'，但是list2的id没变，也就是用的还是用一块内存空间，即没有产生新值，也就是列表是可变类型
# 但是反过来再看列表内的字符串就是不可变类型
list2 = ['haha', 'xixi', 'hehe']
print(id(list2))
print(id(list2[0]))  # 2596136168048
list2[0] = 'niubi'
print(id(list2))
print(id(list2[0]))  # 2596136168240

# 元组
t1 = ('tom', 'jack', [1, 2])
# t1[0] = 'TOM'  # 元组类型只能取不能改
# 元组内的元素无法修改，指的是元组内索引指向的内存地址不能被修改
print(t1)
# 1532888623280
# 1532888623344
# 1532888573568
print(id(t1[0]))
print(id(t1[1]))
print(id(t1[2]))
print(id(t1[2][0]))
t1[2][0] = 111  # 如果元组内的某个元素是可变类型，它的值是可以修改的，但是修改后还是不影响元组内索引指向的内存地址不变，变的只是元组内可变元素的内存地址。
# 1532888623280
# 1532888623344
# 1532888573568
print(id(t1[0]))
print(id(t1[1]))
print(id(t1[2]))
print(id(t1[2][0]))

# 字典类型
dict1 = {'name': 'egon',
         'age': 10,
         'gender': 'male'}

print(id(dict1))  # 2082429610688
dict1['name'] = 'lijipeng'
print(id(dict1))  # 2082429610688

# 字典内值改变后，字典本身的内存地址没变，也就是字典是可变类型

•  test1

name = " aleegonxX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
print(name.strip(' '))
# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果
print(name.startswith('al'))
# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果
print(name.endswith('X'))
# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
print(name.replace('l', 'p'))
# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
print(name.split('l'))
# 6)    将 name 变量对应的值变大写,并输出结果
print(name.upper())
# 7)    将 name 变量对应的值变小写,并输出结果
print(name.lower())
# 8)    请输出 name 变量对应的值的第 2 个字符?
print(name[1])
# 9)    请输出 name 变量对应的值的前 3 个字符?
print(name[0:3])
# 10)    请输出 name 变量对应的值的后 2 个字符?
print(name[-2:])
# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?
print(name.index('e'))
print(name.find('e')) # 推荐使用find
# 12)    获取子序列,去掉最后一个字符。如: egonlin 则获取egonli
# print(name.split(name[-1])[0])
print(name[:-1])

• test2

# 简单购物车,要求如下：
# 实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　

msg_dic = {
    'apple': 10,
    'tesla': 10000,
    'mac': 3000,
    'lenovo': 30000,
    'chicken': 10
}

goods_l = []

while True:
    # 打印商品列表
    for key, item in msg_dic.items():
        print('name = {name},price = {price}'.format(name=key, price=item))
    choice = input('商品>>：').strip()
    if not choice or choice not in msg_dic: continue
    if choice == 'exit': break
    count = input('商品个数>>：').strip()
    if not count.isdigit(): continue

    good_l = [choice, msg_dic[choice], count]
    goods_l.append(good_l)
    print(goods_l)

• test3

# 有如下值集合[11, 22, 33, 44, 55, 66, 77, 88, 99, 90...]，将所有大于
# 66的值保存至字典的第一个key中，将小于66的值保存至第二个key的值中
#
# 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
'''
有如下值集合[11, 22, 33, 44, 55, 66, 77, 88, 99, 90...]，
将所有大于66的值保存至字典的第一个key中，将小于66的值保存至第二个key的值中即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
'''

list1 = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
l1 = []
l2 = []
a = {'k1': l1, 'k2': l2}
for i in list1:
    if i > 66:
        l1.append(i)
    elif i < 66:
        l2.append(i)

print(a)

• test4

'''
统计s="hello egon egon say hello xxx xxx"中每个单词的个数
# 结果如：{"hello":2,"egon":2,"say":1,"xxx":2}
'''

# 我自己想出来的方式1：
s = 'hello egon egon say hello xxx xxx'
msg_keywords = {}
msg_l = s.split(' ')

for keyword in msg_l:
    if keyword not in msg_keywords:
        msg_keywords.setdefault(keyword, 1)
    else:
        msg_keywords.update({keyword: msg_keywords[keyword] + 1})

print(msg_keywords)

# 方式2：使用列表中的count()方法来统计单词的个数
s = 'hello egon egon say hello xxx xxx'
words = s.split(' ')
dic = {}
for word in words:
    dic[word] = words.count(word)
print(dic)

# 方式3：利用setdefault去掉重复值
s = 'hello egon egon say hello xxx xxx'
words = s.split(' ')
dic = {}
for word in words:
    dic.setdefault(word,words.count(word))

print(dic)

# 方式4：利用集合去重
s = 'hello egon egon say hello xxx xxx'
words = s.split(' ')
l = list(words)
dic = {}

for word in l:
    dic[word] = words.count(word)

print(dic)

• test5

'''
关系运算
  有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
  pythons={'xiaohua','egon','mimi','gangdan','biubiu'}
  linuxs={'mimi','xiaohei','gangdan'}
  1. 求出即报名python又报名linux课程的学员名字集合
  2. 求出所有报名的学生名字集合
  3. 求出只报名python课程的学员名字
  4. 求出没有同时这两门课程的学员名字集合
'''
pythons={'xiaohua','egon','mimi','gangdan','biubiu'}
linuxs={'mimi','xiaohei','gangdan'}

print(pythons & linuxs)
print(pythons | linuxs)
print(pythons - linuxs)
print(pythons ^ linuxs)