Python小白学习教程从入门到入坑------第十二课 类型转换&深浅拷贝（语法基础）

目录

一、类型转换

1.1 int()

1.2 float()

1.3 str()

1.4 eval() 

1.5 list()

二、深浅拷贝

2.1 引子

2.2 浅拷贝

2.3 深拷贝

---

---

一、类型转换

1.1 int()

功能：转换为一个整数，只能转换由纯数字组成的字符串

float  ->  int

注意：浮点型强转整型会去掉小数点及后面的数值，只保留整数部分

eg:

a = 1.2
print(type(a))      # 输出内容：<class 'float'>
b = int(a)          # 输出内容：1 <class 'int'>
print(b,type(b))    # 输出内容：1
print(int(1.8))

str  ->  int

注意：如果字符串中有数字和正负号（+/-）以外的字符就会报错，（+/-）写在前面表示正负号，不可以写在后面，否则也会报错

eg:

a = int('123')
print(a,type(a))     # 输出结果：123 <class 'int'>
# print(int('bingbing'))  # 报错
print(int('-10'))    # 输出结果：-10
# +/-写在前面表示正负号，不可以写在后面
# print(int('10-'))         # 报错

小练习：用户从控制台输入，判断年龄

参考：

age = int(input("请输入您的年龄："))  # input默认输入的是字符串类型，用int强制转换成整型
if age >= 18:
    print("成年了")

1.2 float()

 float（）：转换为一个小数

注意：整型转换为浮点型，会自动添加一位小数，如果字符串中有正负号、数字和小数点以外的字符，则不支持转换

eg:

print(float(7))    # 7.0
print(float(-7))    # -7.0
print(float('+12.23'))    # 12.23
# print(float('7-'))  # 报错

1.3 str()

str（）：转换为字符串类型，任何类型都可以转换成字符串类型,float转换成str会取出末位为0的小数部分

eg:

n = 100
print(type(n))   # <class 'int'>
n2 = str(n)
print(n2,type(n2))  # 100 <class 'str'>
st = str(-1.80)
print(st,type(st))  # -1.8 <class 'str'>  float转换成str会取出末位为0的小数部分
li = [1,2,3]
sr = str(li)
print(sr,type(sr))   # [1, 2, 3] <class 'str'>

1.4 eval() 

eval（）：用来执行一个字符串表达式，并返回表达式的值

eval（）非常强大，但是不够安全，容易被恶意修改数据，不建议使用

eg:

print(10+10)    # 20，整型相加，+就是运算符
print('10'+'10')   # 1010，两个字符串相“加”，+是连接符
print('10+10')    # 10+10，输出字符串整体
print(eval('10'+'10'))   # 1010，同样是两个字符串相加
print(eval('10+10'))       # 20，执行字符串运算结果，并返回运算值
# print(eval("10+'10'"))   # 报错，整型和字符串不可以相加

eval（）：可以实现 list、dict、tuple和str之间的转换

str ->  list:

st1 = "[[1,2],[3,4],[5,6]]"
print(type(st1))  # <class 'str'>
li = eval(st1)
print(li,type(li))  # [[1, 2], [3, 4], [5, 6]] <class 'list'>

 str -> dict:

st2 = "{'name':'bingbing','age':18}"
dic = eval(st2)
print(dic,type(dic))    # {'name': 'bingbing', 'age': 18} <class 'dict'>

1.5 list()

list（）：将可迭代对象转换成列表

支持转换为 list 的类型：str、tuple、dict、set

str -> list:

print(list('abcd'))  # ['a', 'b', 'c', 'd']
# print(list(1234))  # 报错，1234不可迭代

tuple -> list:

print(list((1,2,3,4))) # [1, 2, 3, 4]

dict -> list:

注意：字典转换成列表，会取键名作为列表的值

print(list({'name':'bingbing','age':18})) # ['name', 'age']
# 字典转换成列表，会取键名作为列表的值

set -> list:

注意：集合转换成列表，会先去重，再转换  

print(list({'q','e','y','q'}))
# ['y', 'q', 'e']

二、深浅拷贝

2.1 引子

先了解一下什么是赋值

赋值是将一个变量的值或者一个对象的引用赋给另一个变量。在赋值过程中，两个变量会指向同一个内存地址。因此，对其中一个变量的修改会影响另一个变量。

• 特点：

  • 快速且节省内存，因为只是复制了引用。
  • 不能保证数据的独立性和安全性。如果原对象被修改或销毁，赋值后的对象也会受到影响。

赋值：等于完全共享资源，一个值的改变会完全被另一个值共享

eg:

li = [1,2,3,4]
li2 = li  # 将li直接赋值给li2
print("li:",li)
print("l2:",li2)
# 给li列表新增元素
li.append(5)
print('新增后的li：',li)
print('新增后的li2：',li2)
# 输出内容：
# li: [1, 2, 3, 4]
# l2: [1, 2, 3, 4]
# 新增后的li： [1, 2, 3, 4, 5]
# 新增后的li2： [1, 2, 3, 4, 5]

但在有些情况，我们需要保留一份原始数据，然后再去处理原始数据，那么此时用赋值就显得不太明智

在Python中为我们这种需求提供了copy模块，一种是浅拷贝，一种就是深拷贝

2.2 浅拷贝

数据半共享

浅拷贝是创建一个新的对象，但只复制原对象的第一层属性。如果原对象的属性是基本类型（如整数、浮点数、字符串等），那么复制的是值；如果原对象的属性是引用类型（如列表、字典、对象等），那么复制的是引用。

• 特点：

  • 相对于深拷贝来说更快更省内存。
  • 不能完全复制原对象。如果原对象的引用类型属性被修改，浅拷贝后的对象也会受到影响。
  • 拷贝前后对象的基本数据类型互不影响，但拷贝前后对象的引用类型因共享同一块内存，会相互影响。

注意：浅拷贝会创建新的对象，拷贝第一层的数据，嵌套层会指向原来的内存地址

eg:

import copy  # 导入copy模块
li = [1,2,3,[4,5,6]]   # 定义一个嵌套列表
li2 = copy.copy(li)    # 浅拷贝
print('li',li)
print('li2',li2)
# 查看内存地址：id()
print("li内存地址：",id(li))
print("li2内存地址：",id(li2))
# 输出内容：
# li [1, 2, 3, [4, 5, 6]]
# li2 [1, 2, 3, [4, 5, 6]]
# li内存地址： 2807467470920
# li2内存地址： 2807467471176
# 内存地址不一样，说明不是同一个对象

li.append(7)
print('li',li)
print('li2',li2)
# 输出结果：
# li [1, 2, 3, [4, 5, 6], 7]
# li2 [1, 2, 3, [4, 5, 6]]

浅拷贝外层的内存地址不同，但是内层的内存地址相同，当往嵌套列表中添加元素时：

eg:

import copy  # 导入copy模块
li = [1,2,3,[4,5,6]]   # 定义一个嵌套列表
li2 = copy.copy(li)    # 浅拷贝
print('li',li)
print('li2',li2)
# 输出内容：
# li [1, 2, 3, [4, 5, 6]]
# li2 [1, 2, 3, [4, 5, 6]]

# 往嵌套列表中添加元素
li[3].append(7)
print('li',li)
print('li2',li2)
# 输出内容：
# li [1, 2, 3, [4, 5, 6, 7]]
# li2 [1, 2, 3, [4, 5, 6, 7]]
print('li[3]的内存地址',id(li[3]))
print('li2[3]的内存地址',id(li2[3]))
# 输出内容：
# li[3]的内存地址 2318989193608
# li2[3]的内存地址 2318989193608
# 外层的内存地址不同，但内层的内存地址相同

2.3 深拷贝

数据完全不共享

深拷贝是创建一个新的对象，并递归地复制原对象的所有层级的属性。无论原对象的属性是基本类型还是引用类型，都会复制其实际的值。

• 特点：

  • 能够完全复制原对象，保证数据的独立性和安全性。
  • 相对于赋值和浅拷贝来说更慢更占内存，因为需要递归地复制所有对象。
  • 拷贝后的对象与原始对象完全独立，互不影响。

注意：深拷贝是将外层的对象和内部的元素都拷贝了一遍，深拷贝数据变化只影响自己本身，跟原来的对象没有关联

eg：

import copy  # 导入copy模块
li = [1,2,3,[4,5,6]]   # 定义一个嵌套列表
li2 = copy.deepcopy(li)    # 深拷贝
print('li',li,id(li))
print('li2',li2,id(li2))
# 输出内容：
# li [1, 2, 3, [4, 5, 6]] 1825371189960
# li2 [1, 2, 3, [4, 5, 6]] 1825371190216

li.append(8)
print('li',li)
print('li2',li2)
# 输出内容：
# li [1, 2, 3, [4, 5, 6], 8]
# li2 [1, 2, 3, [4, 5, 6]]

# 在嵌套列表添加元素
li[3].append(7)
print('li',li,id(li[3]))
print('li2',li2,id(li2[3]))
# 输出内容：
# li [1, 2, 3, [4, 5, 6, 7], 8] 2602944885320
# li2 [1, 2, 3, [4, 5, 6]] 2602944885576
# 外层的内存地址不同，内层的内存地址也不同