【Python】Python学习笔记6

代码笔记：

'''
类型转换：
int(x):将x转换为整型。
    注意：
    只能转换由纯数字组成的字符串；如果字符串中出现除数字和正负号（写在最前面）以外的字符，就会报错。
    浮点型转换为整型时，只保留整数部分，小数部分舍去。
float(x):将x转换为浮点型。
    注意：
    只能转换由纯数字组成的字符串；如果字符串中出现除数字和正负号（写在最前面）以及小数点以外的字符，就会报错。
    整型转换为浮点型会自动添加一位小数。
'''
print(int('-36'))       # -36
print(int(-3.6))        # -3
print(float(36))        # 36.0
print(float('+5.625'))  # 5.625
'''
str(x):将x转换为字符串类型。
    注意：
    任何对象都能够转换为字符串类型。
    浮点型转换为字符串类型会默认舍去小数末位的0。
'''
print(str(1.560))       # 1.56
li = [1, 2, 3, 4]
print(li, type(li))     # [1, 2, 3, 4] <class 'list'>
li = str(li)
print(li, type(li))     # [1, 2, 3, 4] <class 'str'>
'''
eval(x):计算字符串中的表达式，并返回结果。
        注意：
        eval()可以实现list（列表）、dict（字典）、tuple（元组）和str（字符串）之间的转换。
        在运用eval()实现类型转换时，安全性太低，能够被随意更改数据。
'''
print(10+10)            # 20
print('10+10')          # 10+10
print('10'+'10')        # 1010
print(eval('10+10'))    # 20
print(eval('10'+'10'))  # 1010
st1 = '[[5, 6], [7, 8], [9, 10]]'
print(st1, type(st1))   # [[5, 6], [7, 8], [9, 10]] <class 'str'>
st1 = eval(st1)         # 将字符串（str）转换为列表（list）
print(st1,type(st1))    # [[5, 6], [7, 8], [9, 10]] <class 'list'>
st2 = "{'name' : '小明','age' : 20}"
print(st2, type(st2))   # {'name' : '小明','age' : 20} <class 'str'>
st2 = eval(st2)         # 将字符串（str）转换为字典（dic）
print(st2, type(st2))   # {'name': '小明', 'age': 20} <class 'dict'>
'''
list(x):将可迭代对象x转换为列表。
    注意：
    可迭代对象有：str（字符串） dict（字典） tuple（元组） set（集合）等。
    集合转换为列表会先进行去重操作。
'''
print(list('abcdefg'))  # ['a', 'b', 'c', 'd', 'e', 'f', 'g']；将字符串转换为列表。
print(list({'name': '小红', 'age': 18}))              # ['name', 'age']；默认将字典中的键转换为列表。
print(list({'name': '小红', 'age': 18}.keys()))       # ['name', 'age']；将字典中的键转换为列表。
print(list({'name': '小红', 'age': 18}.values()))     # ['小红', 18]；将字典中的值转换为列表。
print(list({'name': '小红', 'age': 18}.items()))      # [('name', '小红'), ('age', 18)]；将字典中的键值对转换为列表。
print(list(('小明', 20, 18, 1, 2)))                   # ['小明', 20, 18, 1, 2]；将元组转换为列表。
print(list({1, 2, 3, 4, 4, 5, 6, 6}))   # [1, 2, 3, 4, 5, 6]；将集合转换为列表。
'''
深浅拷贝：
    浅拷贝：
        格式：copy().copy(对象) 或者 对象.copy().copy()
        注意：
            浅拷贝属于数据半共享；
            拷贝最外层对象，内层对象只拷贝一个引用（指向内存地址）；
            外层的内存地址不同，但内层的内存地址相同；
            优点：拷贝速度快，占用空间小，拷贝效率高。
    注意：
        一定要导入copy模块即： import copy
        深浅拷贝只针对可变对象：列表（list）、字典（dict）、集合（set）等。
    查看内容地址：id()
'''
import copy     # 导入copy模块
l1 = [1, 2, 3, [4, 5, 6]]   # 定义一个嵌套列表（即列表中还存在一个列表）
l2 = l1                     # 赋值
l3 = l1.copy().copy()       # 浅拷贝
print("列表l1：", l1, "内存地址为：", id(l1))    # 列表l1： [1, 2, 3, [4, 5, 6]] 内存地址为： 1816312515776
print("列表l2：", l2, "内存地址为：", id(l2))    # 列表l1： [1, 2, 3, [4, 5, 6]] 内存地址为： 1816312515776
print("列表l3：", l3, "内存地址为：", id(l3))    # 列表l2： [1, 2, 3, [4, 5, 6]] 内存地址为： 1816312516928
l1.append(7)
print("列表l1：", l1, "内存地址为：", id(l1))    # 列表l1： [1, 2, 3, [4, 5, 6], 7] 内存地址为： 2749855997184
print("列表l2：", l2, "内存地址为：", id(l2))    # 列表l2： [1, 2, 3, [4, 5, 6], 7] 内存地址为： 2749855997184
print("列表l3：", l3, "内存地址为：", id(l3))    # 列表l3： [1, 2, 3, [4, 5, 6]] 内存地址为： 2749855998336
l1[3].append(8)
print("原来列表l1：", l1, "内存地址为：", id(l1))    # 原来列表l1： [1, 2, 3, [4, 5, 6, 8], 7] 内存地址为： 1804033432640
print("赋值列表l2：", l2, "内存地址为：", id(l2))    # 赋值列表l2： [1, 2, 3, [4, 5, 6, 8], 7] 内存地址为： 1804033432640
print("浅拷贝列表l3：", l3, "内存地址为：", id(l3))    # 浅拷贝列表l3： [1, 2, 3, [4, 5, 6, 8]] 内存地址为： 1804033433792
'''
深拷贝：内外层对象都进行拷贝。
        格式：copy.deepcopy(对象)
        注意：深拷贝属于数据完全不共享（一旦完成拷贝，对原对象进行操作拷贝后的对象数据不发生改变）。
'''
import copy     # 导入copy模块
li1 = [3, 4, 5, 6, [8, 9, 10]]  # 定义嵌套列表
li2 = copy.deepcopy(li1)     # 深拷贝
li1.append(7)           # 对外层列表添加元素
print(li1, id(li1))     # [3, 4, 5, 6, [8, 9, 10], 7] 2195115449408
print(li2, id(li2))     # [3, 4, 5, 6, [8, 9, 10]] 2195115450240
li1[4].append(11)       # 对内层列表添加元素
print(li1, id(li1[4]))     # [3, 4, 5, 6, [8, 9, 10, 11], 7] 1903551028416
print(li2, id(li2[4]))     # [3, 4, 5, 6, [8, 9, 10]] 1903551029312
'''
可变对象：
    存储空间保存的数据允许被修改的对象，这种就是可变对象。
    对应变量的值可以被修改，但是内存地址不会发生改变。
常见的可变对象：列表（list）、字典（dict）、集合（set）。
'''
lis1 = [1, 2, 3, 4]     # 创建列表
print('原来的列表lis1：', lis1, '内存地址：', id(lis1))    # 原来的列表lis1： [1, 2, 3, 4] 内存地址： 1621191204608
lis1.append(5)      # 添加元素
print('现在的列表lis1：', lis1, '内存地址：', id(lis1))    # 现在的列表lis1： [1, 2, 3, 4, 5] 内存地址： 1621191204608
dic = {'姓名': '小李', '年龄': 18}    # 创建字典
print('原来的字典dic：', dic.items(), '内存地址：', id(dic))   # 原来的字典dic： dict_items([('姓名', '小李'), ('年龄', 18)])
# 内存地址： 3077456228992
dic['姓名'] = '小明'    # 修改元素
print('现在的字典dic：', dic.items(), '内存地址：', id(dic))   # 现在的字典dic： dict_items([('姓名', '小明'), ('年龄', 18)])
# 内存地址： 3077456228992
se1 = {1, 2, 3, 4}      # 创建集合
print(se1, type(se1), id(se1))      # {1, 2, 3, 4} <class 'set'> 2331770674752
se1.remove(2)              # 删除元素
print(se1, type(se1), id(se1))      # {1, 3, 4} <class 'set'> 2331770674752
'''
不可变对象：
    存储空间保存的数据不允许被修改的对象，这种就是可变对象。
    对应变量的值可以被不可以修改，如果修改就会生成一个新的值，从而分配新的内存空间。
常见的可变对象：数值类型（int、float、bool、complex）、字符串（str）、元组（tuple）。
'''
n = 5   # 整型
print('原来的n=%d的内存地址：%s' % (n, id(n)))    # 原来的n=5的内存地址：140723551278992
n = 6   # 修改n的值就会生成新的值，重新赋值给n，内存地址发生改变。
print('修改后n=%d的内存地址：%s' % (n, id(n)))    # 修改后n=6的内存地址：140723551279024
st = 'Hello'  #字符串
print('原来的st = %s 的内存地址：%s' % (st, id(st)))     # 原来的st = Hello 的内存地址：1512686114736
st += 'World'     # 修改字符串内容
print('修改后的st = %s 的内存地址：%s' % (st, id(st)))    # 修改后的st = HelloWorld 的内存地址：1512687349104
tua = (1, 2, 3)     # 元组
print('原来的tua = %s 的内存地址：%s' % (tua, id(tua)))  # 原来的tua = (1, 2, 3) 的内存地址：2687113898496
tua = ('a', 'b', 'c')   # 修改元组内容
print('修改后tua = %s 的内存地址：%s' % (tua, id(tua)))  # 修改后tua = ('a', 'b', 'c') 的内存地址：2687114691328

运行结果：

-36
-3
36.0
5.625
1.56
[1, 2, 3, 4] <class 'list'>
[1, 2, 3, 4] <class 'str'>
20
10+10
1010
20
1010
[[5, 6], [7, 8], [9, 10]] <class 'str'>
[[5, 6], [7, 8], [9, 10]] <class 'list'>
{'name' : '小明','age' : 20} <class 'str'>
{'name': '小明', 'age': 20} <class 'dict'>
['a', 'b', 'c', 'd', 'e', 'f', 'g']
['name', 'age']
['name', 'age']
['小红', 18]
[('name', '小红'), ('age', 18)]
['小明', 20, 18, 1, 2]
[1, 2, 3, 4, 5, 6]
列表l1： [1, 2, 3, [4, 5, 6]] 内存地址为： 1914386686400
列表l2： [1, 2, 3, [4, 5, 6]] 内存地址为： 1914386686400
列表l3： [1, 2, 3, [4, 5, 6]] 内存地址为： 1914386686208
列表l1： [1, 2, 3, [4, 5, 6], 7] 内存地址为： 1914386686400
列表l2： [1, 2, 3, [4, 5, 6], 7] 内存地址为： 1914386686400
列表l3： [1, 2, 3, [4, 5, 6]] 内存地址为： 1914386686208
原来列表l1： [1, 2, 3, [4, 5, 6, 8], 7] 内存地址为： 1914386686400
赋值列表l2： [1, 2, 3, [4, 5, 6, 8], 7] 内存地址为： 1914386686400
浅拷贝列表l3： [1, 2, 3, [4, 5, 6, 8]] 内存地址为： 1914386686208
[3, 4, 5, 6, [8, 9, 10], 7] 1914386276160
[3, 4, 5, 6, [8, 9, 10]] 1914386275968
[3, 4, 5, 6, [8, 9, 10, 11], 7] 1914386686272
[3, 4, 5, 6, [8, 9, 10]] 1914386274752
原来的列表lis1： [1, 2, 3, 4] 内存地址： 1914386149120
现在的列表lis1： [1, 2, 3, 4, 5] 内存地址： 1914386149120
原来的字典dic： dict_items([('姓名', '小李'), ('年龄', 18)]) 内存地址： 1914386161280
现在的字典dic： dict_items([('姓名', '小明'), ('年龄', 18)]) 内存地址： 1914386161280
{1, 2, 3, 4} <class 'set'> 1914386293920
{1, 3, 4} <class 'set'> 1914386293920
原来的n=5的内存地址：140724044175248
修改后n=6的内存地址：140724044175280
原来的st = Hello 的内存地址：1914386686896
修改后的st = HelloWorld 的内存地址：1914386688368
原来的tua = (1, 2, 3) 的内存地址：1914386274304
修改后tua = ('a', 'b', 'c') 的内存地址：1914386275328

Process finished with exit code 0