目录

  • 一、数据类型
  • 二、整形int
  • 2.1 用途
  • 2.2 定义方式
  • 2.3 常用方法
  • 2.3.1 进制之间的转换
  • 2.3.2 数据类型转换
  • 3 类型总结
  • 三、浮点型float
  • 3.1 用途
  • 3.2 定义方式
  • 3.3 常用方法
  • 3.4 数字类型转换
  • 3.5 类型总结
  • 四、字符串类型
  • 3.1 用途
  • 3.2 定义方式
  • 3.3 优先掌握的知识点
  • 3.3.1索引取值
  • 3.3.2 索引切片
  • 3.3.3 成员运算：
  • 3.3.4 .strip()
  • 3.3.5 split
  • 3.3.6 len()
  • 3.4 优先掌握的知识点
  • 3.4.1 strip，rstrip, lstrip
  • 3.4.2 lower\upper
  • 3.4.3 startswith\endswith
  • 3.4.4 .format()
  • 3.4.4 split\rsplit
  • 3.4.5 join
  • 3.4.6 replace
  • 3.4.7 .isdigit()
  • 3.5 字符串了解的知识点
  • 3.5.1 find
  • 3.5.2 index
  • 3.5.3 count
  • 3.5.4 center\ljust\rjust\zfill
  • 3.6 类型总结
  • 五、 list列表类型
  • 5.1 用途
  • 5.2 定义方式
  • 5.3 优先掌握的知识点
  • 5.3.1 索引取值
  • 5.3.2 索引切片
  • 5.3.3 append()
  • 5.3.4 insert()
  • 5.3.5 extend()
  • 5.3.6 remove()
  • 5.3.7 pop()
  • 5.3.8 del
  • 5.3.9 .reverse()
  • 5.3.10 .sort()给列表内所有元素排序
  • 5.3.11 .count()
  • 5.3.12 .index()
  • 5.3.13 clear()
  • 5.4 队列和堆栈
  • 5.4.1 队列
  • 5.4.2 堆栈
  • 5.5 类型总结
  • 六、 元组
  • 6.1 用途
  • 6.2 定义方式
  • 6.3 类型转换
  • 6.4 使用
  • 6.4.1 按索引取值
  • 6.4.2 切片(顾头不顾尾，步长)
  • 6.4.3 len() 长度
  • 6.4.4 成员运算 in 和 not in
  • 6.4.5 循环 for 取值
  • 七、 字典
  • 7.1 定义方式
  • 7.2 类型转换
  • 7.3 使用
  • 7.3.1 优先掌握的操作
  • 7.3.1.1 按key存取值：可存可取
  • 7.3.1.2 长度len()
  • 7.3.1.3 成员运算in和not in
  • 7.3.1.4 删除 pop
  • 7.3.1.5 键keys()，值values()，键值对items()
  • 7.3.1.6 循环for取值
  • 6.3.2 需要掌握的操作
  • 1.get()
  • 2.pop()
  • 3.popitem()
  • 4.update()
  • 5.fromkeys()
  • 6.setdefault()
  • 七 集合
  • 7.1 作用
  • 7.2 定义
  • 7.3 类型转换
  • 7.4 使用
  • 7.4.1 关系运算
  • 7.4.2 去重
  • 7.4.3 其他操作
  • 7.5 练习
  • 八 可变类型与不可变类型
  • 九 数据类型总结

一、数据类型

数据类型是用来记录事物状态的，而事物的状态是不断变化的

二、整形int

2.1 用途

  • 一般用于定义整数，例如年龄等
  • 数字类型主要就是用来做数学运算与比较运算，因此数字类型除了与运算符结合使用之外，无需掌握的内置方法

2.2 定义方式

age = 18  # age = int(18)

2.3 常用方法

2.3.1 进制之间的转换

  • 其他进制转十进制
# 二进制转十进制
print(int("110",2))

# 八进制转十进制
print(int("123",8))

# 十六进制转
print(int("321",16))
  • 十进制转其他进制
# 十进制转二进制：
print(bin(108))  # 0b 1101100

# 十进制转八进制：
print(oct(83))   # 0o 123

# 十进制转十六进制：
print(hex(1000))  # 0x 3e8

2.3.2 数据类型转换

int可以将由纯整数构成的字符串直接转成整形，若包含其他任意非整数符号，则会报错

s = '123'
res = int(s)

# 若想转换带有小数点的数字，需要先转成float类型，再次转为int类型，不可以直接转换。
s = '12.0'
res_float = float(s)
int_float = int(res_float)

3 类型总结

值变id不变就是可变类型

值变id也变就是不可变类型

有索引的类型都是有序的

因此，整形：

  • 不可变类型
  • 无序
  • 存在一个值

三、浮点型float

3.1 用途

用于记录小数，身高，体重，薪资

3.2 定义方式

height = 180.0  # height = float(180.0)

3.3 常用方法

  • 数学计算
  • 数字类型转换

3.4 数字类型转换

字符串 ---> float ---> int

s1 = '1.0'
f1 = float(s1)
print(f1)
print(type(f1))
a1 = int(f1)
print(a1)

3.5 类型总结

值变id不变是可变类型

值变id也变是不可变类型

有索引的类型都是有序的

因此，浮点型：

  • 不可变类型
  • 无序
  • 存在一个值

四、字符串类型

3.1 用途

用于存储一些描述性信息，如名字

3.2 定义方式

name = '高弟'

# 补充：字符串前面加一个小写的r，代表转义

3.3 优先掌握的知识点

3.3.1索引取值

索引取值（正向取、反向取），只能取不能存

s1 = 'hello world'

# 按照索引取值，取hello中的o
print(s1[4])  # 正向取
print(s1[-7])  # 反向取

3.3.2 索引切片

截取字符串中的一小段字符串

# 取world
print(s1[6:11])
print(s1[6:])
# 取hello
print(s1[:6])
print(s1[0:-2:2]) # 从0开始取值，每隔2个取一个，到索引为-2结束

3.3.3 成员运算：

  • in
  • not in
# 判断o是否在s1中
print('o' in s1)
print('o' not in s1)
# 返回结果是bool值
True
False

3.3.4 .strip()

默认去除字符首尾的空格，还可以传入参数指定去除字符

input无论接受的是什么类型，一定返回的是字符串

a1 = '    sean   '
print(len(a1))
print(a1.strip())
print(len(a1.strip()))

11
sean
4

3.3.5 split

切分，对字符串进行切分，可以指定切分的分隔符，返回是一个列表

a1 = '8215\宿舍\逝去的记忆'
print(a1.split('\\'))

['8215', '宿舍', '逝去的记忆']

# 在python中单斜杠有特殊意义
# python中\\双斜杠代表\自己本身

3.3.6 len()

获取当前数据中的元素的个数

s1 = '你好啊世界'
print(len(s1))

5

3.4 优先掌握的知识点

3.4.1 strip，rstrip, lstrip

# rstrip 去掉右边的字符
a1 = '******sean*******'
print(len(a1))
print(a1.rstrip('*'))
print(len(a1.rstrip('*')))

******sean

# lstrip 去掉左边的字符

3.4.2 lower\upper

  • lower 全部变成小写
  • upper 全部变成大写
s1 = 'Hello world'

print(s1.upper())
print(s1.lower())

HELLO WORLD
hello world

3.4.3 startswith\endswith

判断当前字符串是否以XXX开头，或者以XXX结尾，返回的一定是布尔值。

a1 = 'hello python'
print(a1.startswith('h'))
print(a1.endswith('o'))

True
False

3.4.4 .format()

格式化字符串

name = 'sean'
age = '18'

print('my name is {names}, my age is {ages}'.format(names=name, ages=age))

my name is sean, my age is 18

# print("你的名字是：{name}，你的年龄是：{age},{gender}".format(age=age,name=name,gender='male'))

# 通过大括号接收变量，在字符串前面一定要加一个小写f，，，，在python3.6以后才有
# print(f"你的名字是：{name}，你的年龄是：{age}")

3.4.4 split\rsplit

l1 = '我的，杯子，是透明的'
print(l1.split('，', 1))  # 可以指定切分次数
print(l1.rsplit('，', 1))  # 从右边开始切分

3.4.5 join

将传入的（列表）中每一个字符，依次取出，以指定的分隔符进行拼接(传入的列表内只能是字符串)

l1 = ['我的', '杯子', '是透明的']
print('-'.join(l1))
我的-杯子-是透明的

3.4.6 replace

将字符串中的某一段文字进行替换，参数，先老值，再新值

s1 = 'you are my sunshine'
print(s1.replace('sunshine', 'eye'))

you are my eye

3.4.7 .isdigit()

判断当前字符串中是否为整数，bytes、unicode，返回布尔值

score = input('please enter your score：')

if score.isdigit():
    score = int(score)
    if score >= 90:
        print('优秀')
else:
    print('输入有误')

3.5 字符串了解的知识点

3.5.1 find

查找当前字符串中某个元素的位置，返回索引，找不到返回-1

s1 = '你今天吃饭吃了吗？'
print(s1.find("？",))

3.5.2 index

查找当前字符串中某个元素的位置，返回索引，找不到返回异常

print(s1.index("？"))

3.5.3 count

统计当前字符串中某一个元素的个数

print(s1.count("吃"))

3.5.4 center\ljust\rjust\zfill

print("欢迎光临".center(8,"-"))
print("欢迎光临".ljust(30,"-"))
print("欢迎光临".rjust(30,"-"))
print("欢迎光临".zfill(50))

3.6 类型总结

  • 有序
  • 不可变类型
  • 存一个值

五、 list列表类型

5.1 用途

用于存一个或者多个不同类型的值

5.2 定义方式

通过中括号存值，每个值之间通过逗号进行分隔

5.3 优先掌握的知识点

5.3.1 索引取值

l1 = [1, 2, 3, 4,5]
print(l1[2])
l1[2] = 222
print(l1)

5.3.2 索引切片

print(l1[1:4])

5.3.3 append()

在列表尾部追加单个字符

l1 = [1, 2, 3, 4, 5]
l1.append(10000)
print(l1)
l1.append([9,0])
print(l1)

[1, 2, 3, 4, 5, 10000]
[1, 2, 3, 4, 5, 10000, [9, 0]]

5.3.4 insert()

指定索引在列表中插入单个元素

l1 = [1, 2, 3, 4, 5]
l1.insert(3,999)
print(l1)

[1, 2, 3, 999, 4, 5]

5.3.5 extend()

从尾部一次性插入多个值

l1 = [1, 2, 3, 4, 5]
l1.extend([0, 6, 7, 8])

print(l1)
[1, 2, 3, 4, 5, 0, 6, 7, 8]

5.3.6 remove()

指定值删除，比较彻底

l1.remove(1)
print(l1)

5.3.7 pop()

不传值，默认从最后开始删，指定索引删值,pop是有返回值的

l1 = [1, 2, 3, 4,5]

val = l1.pop(2)
print(l1)
print(val)

# 不传值默认从最后面删除
l1.pop()
print(l1)
l1.pop()
print(l1)
l1.pop()
print(l1)

5.3.8 del

万能删除，指定索引

#del l3[0]

5.3.9 .reverse()

反转

l = [11,22,33,44]
l.reverse() 
l
[44,33,22,11]

>>> l = [11,22,3,42,7,55]
>>> l.sort()
>>> l 
[3, 7, 11, 22, 42, 55]  # 默认从小到大排序
>>> l = [11,22,3,42,7,55]
>>> l.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False
>>> l 
[55, 42, 22, 11, 7, 3]

5.3.10 .sort()给列表内所有元素排序

排序，在原列表上进行排序操作

排序时列表元素之间必须是相同数据类型，不可混搭，否则报错

列表级的排序

l2 = [3, 2, 2, 4, 1, 5, 6]
l2.sort()
print(l2)

[1, 2, 2, 3, 4, 5, 6]
Process finished with exit code 0
l2 = [3, 2, 2, 4, 1, 5, 6]
l2.sort(reverse=True)  # reverse=True用来指定排序为倒序，默认为False
print(l2)r

[6, 5, 4, 3, 2, 2, 1]
Process finished with exit code 0

python的内置函数，在排序时生成了一个新列表，原数据不变

l2 = [3, 2, 2, 4, 1, 5, 6]
l3 = sorted(l2,)
print(l3)

5.3.11 .count()

统计当前列表内指定元素的个数

l1 = ['sean', 'egon', 'tank', 'sean']
# count:统计当前列表内指定元素的个数
print(l1.count('sean'))

2

5.3.12 .index()

获取当前指定元素的索引值，还可以指定指定查找范围

l1 = ['sean', 'egon', 'tank', 'sean']
print(l1.index('sean', 1, 4))

5.3.13 clear()

清空列表数据

l2 = [3, 2, 2, 4, 1, 5, 6]
print(l2)
l2.clear()
print(l2)

[3, 2, 2, 4, 1, 5, 6]
[]

Process finished with exit code 0

5.4 队列和堆栈

5.4.1 队列

先进先出（先吃后拉）

5.4.2 堆栈

先进后出 （先吃后涂）

5.5 类型总结

  • 有序
  • 可变
  • 存在多个值

六、 元组

6.1 用途

元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取

6.2 定义方式

用过小括号存储数据，数据与数据之间通过逗号分隔,(值不能被改变)

  • 定义容器类型的时候，如果里面只有一个值，在值的后面加上一个逗号
  • 在元组中如果不加，就是字符串
# 在()内用逗号分隔开多个任意类型的值
>>> countries = ("中国"，"美国"，"英国")  # 本质:countries = tuple("中国"，"美国"，"英国")
# 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组
>>> countries = ("中国"，)  # 本质:countries = tuple("中国")

6.3 类型转换

# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
t1 = tuple([1, 2, 3, 4, 5])  # 列表转为元组
print(t1)
print(type(t1))

(1, 2, 3, 4, 5)
<class 'tuple'>


t1 = tuple('你好啊世界！')  # 字符串转元组
print(t1)
print(type(t1))

('你', '好', '啊', '世', '界', '！')
<class 'tuple'>

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

6.4 使用

6.4.1 按索引取值

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

6.4.2 切片(顾头不顾尾，步长)

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

6.4.3 len() 长度

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

6.4.4 成员运算 in 和 not in

# 4、成员运算 in 和 not in
>>> 'hhaha' in tuple1 
True
>>> 'hhaha' not in tuple1  
False

6.4.5 循环 for 取值

# 5、循环
>>> for line in tuple1:
...     print(line)
1
hhaha
15000.0
11
22
33

七、 字典

7.1 定义方式

通过大括号来存储数据，通过key: value的关系映射键值对，每个键值对中间通过逗号分隔

  • key:一定是一个不可变类型
  • value：可以是任意类型
# 定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，通常key应该是str类型，因为str类型会对value有描述性的功能
info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})

# 也可以这么定义字典
info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}

# zip的定义方式：了解即可
l1 = ['name',"age"]
l2 = ['egon',18]
z1 = zip(l1,l2)
print(dict(z1))

7.2 类型转换

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

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

7.3 使用

7.3.1 优先掌握的操作

7.3.1.1 按key存取值：可存可取
# 1、按key存取值：可存可取
# 1.1 取
>>> dic = {
...     'name': 'xxx',
...     'age': 18,
...     'hobbies': ['play game', 'basketball']
... }
>>> dic['name']
'xxx'
>>> dic['hobbies'][1]
'basketball'
# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value
>>> dic['gender'] = 'male'  
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}
# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
>>> dic['name'] = 'tony'
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}
7.3.1.2 长度len()
# 2、长度len
>>> len(dic) 
3
7.3.1.3 成员运算in和not in
# 3、成员运算in和not in
>>> 'name' in dic  # 判断某个值是否是字典的key
True
7.3.1.4 删除 pop
# 4、删除
>>> dic.pop('name')  # 通过指定字典的key来删除字典的键值对
>>> dic
{'age': 18, 'hobbies': ['play game', 'basketball']}
7.3.1.5 键keys()，值values()，键值对items()
# 5、键keys()，值values()，键值对items()
>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 获取字典所有的key
>>> dic.keys()  
dict_keys(['name', 'age', 'hobbies'])
# 获取字典所有的value
>>> dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])
# 获取字典所有的键值对
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

7.3.1.6 循环for取值

# 6、循环
# 6.1 默认遍历的是字典的key
>>> for key in dic:
...     print(key)
... 
age
hobbies
name
# 6.2 返回所有的键，以列表的形式
>>> for key in dic.keys():
...     print(key)
... 
age
hobbies
name
# 6.3 返回所有的值
>>> for key in dic.values():
...     print(key)
... 
18
['play game', 'basketball']
xxx
# 6.4 返回所有的键值对
>>> for key in dic.items():
...     print(key)
... 
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')

6.3.2 需要掌握的操作

1.get()
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.get('k1')
'jason'  # key存在，则获取key对应的value值
>>> res=dic.get('xxx') # key不存在，不会报错而是默认返回None
>>> print(res)
None  
>>> res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
>>> print(res)
666 
# ps:字典取值建议使用get方法
2.pop()
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> v = dic.pop('k2')  # 删除指定的key对应的键值对,并返回值
>>> dic
{'k1': 'jason', 'kk2': 'JY'}
>>> v
'Tony'
3.popitem()
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> item = dic.popitem()  # 随机删除一组键值对,并将删除的键值放到元组内返回
>>> dic
{'k3': 'JY', 'k2': 'Tony'}
>>> item
('k1', 'jason')
4.update()
# 用新字典更新旧字典，有则修改，无则添加
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}
5.fromkeys()

将逗号后面的值依次传入到前面的key中并组成字典

>>> dic = dict.fromkeys(['k1','k2','k3'],[])
>>> dic
{'k1': [], 'k2': [], 'k3': []}
6.setdefault()

如果传入的值已存在于字典，返回原来的value

如果传入的值不存在于字典，新增一条数据，返回更新之后的value

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

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

七 集合

7.1 作用

集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

7.2 定义

"""
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
     1：每个元素必须是不可变类型
     2：集合内没有重复的元素
     3：集合内元素无序
"""
s = {1,2,3,4}  # 本质 s = set({1,2,3,4})

# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} # 默认是空字典 
s = set() # 这才是定义空集合

7.3 类型转换

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

7.4 使用

7.4.1 关系运算

我们定义两个集合friends与friends2来分别存放两个人的好友名字，然后以这两个集合为例讲解集合的关系运算

>>> friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们 
>>> friends2 = {"Jy","ricky","jason","egon"}   # 用户2的好友们

两个集合的关系如下图所示

python 中的int8 python int8方法_字符串

# 1.合集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}

# 2.交集(&)：求两个用户的共同好友
>>> friends1 & friends2
{'jason', 'egon'}

# 3.差集(-)：
>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}

# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}

# 5.值是否相等(==)
>>> friends1 == friends2
False

# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含关系，则返回True
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False


# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True

7.4.2 去重

集合去重复有局限性

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

示例如下

>>> l=['a','b',1,'a','a']
>>> s=set(l)
>>> s # 将列表转成了集合
{'b', 'a', 1}
>>> l_new=list(s) # 再将集合转回列表
>>> l_new
['b', 'a', 1] # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]

new_l=[]

for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
    {'age': 18, 'sex': 'male', 'name': 'lili'}, 
    {'age': 73, 'sex': 'male', 'name': 'jack'}, 
    {'age': 20, 'sex': 'female', 'name': 'tom'}
]

7.4.3 其他操作

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

# 2.成员运算
>>> 'c' in s
True

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

7.5 练习

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

八 可变类型与不可变类型

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

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

数字类型:

>>> x = 10
>>> id(x)
1830448896 
>>> x = 20
>>> id(x)
1830448928
# 内存地址改变了，说明整型是不可变数据类型，浮点型也一样

python 中的int8 python int8方法_取值_02

字符串

>>> x = "Jy"
>>> id(x)
938809263920 
>>> x = "Ricky"
>>> id(x)
938809264088
# 内存地址改变了，说明字符串是不可变数据类型

python 中的int8 python int8方法_字符串_03

列表

>>> list1 = ['tom','jack','egon']
>>> id(list1)
486316639176
>>> list1[2] = 'kevin'
>>> id(list1)
486316639176
>>> list1.append('lili')
>>> id(list1)
486316639176
# 对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型

python 中的int8 python int8方法_python 中的int8_04

元组

>>> t1 = ("tom","jack",[1,2])
>>> t1[0]='TOM' # 报错：TypeError
>>> t1.append('lili') # 报错：TypeError
# 元组内的元素无法修改，指的是元组内索引指向的内存地址不能被修改
>>> t1 = ("tom","jack",[1,2])
>>> id(t1[0]),id(t1[1]),id(t1[2])
(4327403152, 4327403072, 4327422472)
>>> t1[2][0]=111 # 如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变
>>> t1
('tom', 'jack', [111, 2])
>>> id(t1[0]),id(t1[1]),id(t1[2]) # 查看id仍然不变
(4327403152, 4327403072, 4327422472)

python 中的int8 python int8方法_元组_05

字典

>>> dic = {'name':'egon','sex':'male','age':18}
>>> 
>>> id(dic)
4327423112
>>> dic['age']=19
>>> dic
{'age': 19, 'sex': 'male', 'name': 'egon'}
>>> id(dic)
4327423112
# 对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型

python 中的int8 python int8方法_取值_06

九 数据类型总结

python 中的int8 python int8方法_元组_07