• python入门之数据类型及内置方法

    目录

    一、数据类型

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

    二、整形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 lowerupper

    • lower 全部变成小写

    • upper 全部变成大写

    s1 = 'Hello world'

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

HELLO WORLD
hello world

    3.4.3 startswithendswith

    判断当前字符串是否以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 split

    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 centerljust justzfill

    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的好友们

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

    img

    # 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
# 内存地址改变了，说明整型是不可变数据类型，浮点型也一样

    img

    字符串

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

    img

    列表

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

    img

    元组

    >>> 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)

    img

    字典

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

    img

    九 数据类型总结

    img
  • 相关阅读:
    vue table 中 列 加上 下划线和click 方法
    vue 比较好的学习文章
    Hive 以及mysql 中如何做except 数据操作
    oracle 日期维表 原始版本 带注解
    RMI 实现的rpc 远程过程调用 Java
    剑指offer20：定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
    剑指offer19：按照从外向里以顺时针的顺序依次打印出每一个数字，4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.
    模拟通讯录
    剑指offer17：输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
    剑指offer16：输入两个单调递增的链表，合成后的链表满足单调不减规则。
  • 原文地址：https://www.cnblogs.com/cnhyk/p/11813435.html
Copyright © 2020-2023  润新知