第三章数据类型

阅读目录

第三章数据类型

第三章数据类型

3.1 整型（int）

任意大小的整数，当然包括负整数

 >>> 100
100
>>> -9999
-9999
>>>

3.1.1 整型的长度

python2：

在32位机器上，整数的位数为32位，取值范围为-231～231-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-263～263-1，即-9223372036854775808～9223372036854775807
超出长度之后就会变为long类型

python3：

只有int没有long，所有数字都是int类型。

3.1.2 整除

在python2中使用除法时，只能保留整数位，如果想要保留小数位，可以先导入一个模块。

 >>> from __future__ import division
>>> value = 3/2
>>> print(value)
1.5
>>>
>>> value = 10/3
>>> print(value)
3.33333333333

3.2 布尔（bool）

一个布尔值只有True,False两种值，要么是true要么是false

布尔值就是用于表示真假。True和False。

 >>> True
True
>>> 3 > 2
True
>>> False
False
>>> 3 > 5
False
>>> 30 > 66
False
>>> 444 > 333
True
>>>

其他类型转换成布尔值：

对于：None / "" / 0 .... -> false

3.3 字符串（str）

字符串是写代码中最常见的，python内存中的字符串是按照：unicode 编码存储。对于字符串是不可变。

3.3.1 字符串相加

字符串拼接,相加的规则就是必须都是字符串才能相加

 >>> a = "hello"
>>> b = "word"
>>> print(a+b)
helloword

3.3.2 字符串相乘

字符串的乘法就是将多个字符串拼接到一起,乘法的规则:只能是字符串和数字相乘

 >>> a = "hello"
>>> b = 5
>>> print(a*b)
hellohellohellohellohello

字符串中是不能进行减法和除法操作的

3.3.3 索引

索引就是对字符串中的每个元素从左到右进行有序的编码，从0开始，所以每个字符串中的第一个元素的索引就是0.

当索引是负数是，表示从右到左取元素，由于-0等于0，所以，-1就代表了从右到左的第一个元素

示例

 >>> name = "ABCDE"
>>> print(name[0])
A
>>> print(name[1])
B
>>> print(name[2])
C
>>> print(name[-1])
E
>>> print(name[-2])
D
>>> print(name[-0])
A

3.3.4 切片

切片就是通过索引取出字符串的某一段，[第一个位置是开始:第二个位置是终止]中间必须使用分号。

默认终止的索引是不会包含在获取的内容中

示例

 >>> name = "ABCDE"
>>> print(name[:1])
A
>>> print(name[1:])
BCDE
>>> print(name[1:4])
BCD
>>> print(name[1:-1])
BCD
>>> print(name[1:-2])
BC

3.3.5 步长

中括号里第一个参数是起始位置,第二参数是终止位置,第三个参数现在告诉大家是步长(每次走几步)

 >>> name = "ABCDE"
>>>
>>> print(name[:1:2])
A
>>> print(name[::2])
ACE
>>> print(name[::-2]) # 负数就是倒着取
ECA
>>>

3.3.6 字符串方法详解

【补充】首字母大写、大小写翻转、每个隔开的（特殊字符和数字）单词首字母大写

  s = 'alex Wusir' #首字母大写
 s1 = s.capitalize()  #首字母大写# print(s1) #Alex wusir
 
 s3 = s.swapcase() #大小写翻转
 print(s3) #ALEX wUSIR
 
 a = 'zhangyang zy yy'
 a1 = a.title() #每个隔开的（特殊字符和数字）单词首字母大写
 print(a1) #Zhangyang Zy Yy

1.全部大写 upper()

示例

 >>> name = 'abcdef'
>>> new_name = name.upper()
>>> print(new_name)
ABCDEF
 
#######
 
>>> name = 'ABCdef123'
>>> new_name = name.upper()
>>> print(new_name)
ABCDEF123
>>>
##################
v = 'ALEX'
v1 = v.upper()
print(v1)
v2 = v.isupper() # 判断是否全部是大写
print(v2)

2.全部小写 lower()

示例

 >>> name = 'ABCDEF'
>>> new_name = name.lower()
>>> print(new_name)
abcdef
 
################
 
>>> name = 'ABCdef123'
>>> new_name = name.lower()
>>> print(new_name)
abcdef123

3.字符串替换 replace()

replace() 方法把字符串中的 old（旧字符串）替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次

replace()方法语法：

 str.replace(old, new[, max])

参数

 old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次

示例

 message = input('请说话：')
print(message)
data = message.replace('大爷',"**",2)# 将大爷替换成**，替换不超过2次
print(data)

4.去除字符 strip()

strip()的语法

 str.strip([chars])

参数

 chars 代表要去除的字符，默认是空格

strip() 是去除头尾。

示例

 name = '  AB, CD, E, F,  G  '
new_name = name.strip()
print("--->",new_name,"<---")
---> AB, CD, E, F,  G <---

lstrip() 是去除左边的字符

示例

 name = '  AB, CD, E, F,  G  '
new_name = name.lstrip()
print("--->",new_name,"<---")
---> AB, CD, E, F,  G   <---

rstrip()是去除右边的字符

示例

 name = '  AB, CD, E, F,  G  '
new_name = name.rstrip()
print("--->",new_name,"<---")
--->   AB, CD, E, F,  G <---

5.字符切割 split()

通过指定分隔符对字符串进行切片

split() 语法：

 str.split(分隔符, 分割次数)

split() 从左到右切割

rsplit() 从右到左切割

示例

 >>> message = "小黑现在一脸懵逼，因为昨天晚上一直在学习，直到深夜。"
>>> result = message.rsplit('，',1)
>>> print(result)
['小黑现在一脸懵逼，因为昨天晚上一直在学习', '直到深夜。']
>>> result = message.rsplit('，')
>>> print(result)
['小黑现在一脸懵逼', '因为昨天晚上一直在学习', '直到深夜。']

6.判断是否是数字： isdecimal/.isdigit()

 v = '1'
# v = '二'
# v = '②'
v1 = v.isdigit()  # '1'-> True; '二'-> False; '②' --> True
v2 = v.isdecimal() # '1'-> True; '二'-> False; '②' --> False
v3 = v.isnumeric() # '1'-> True; '二'-> True; '②' --> True
print(v1,v2,v3)
# 以后推荐用 isdecimal 判断是否是 10进制的数。
 
# ############## 应用 ##############
 
v = ['alex','eric','tony']
 
for i in v:
    print(i)
 
num = input('请输入序号：')
if num.isdecimal():
    num = int(num)
    print(v[num])
else:
    print('你输入的不是数字')

7.是否以什么开头.startswith()

 name = 'AB, CD, E, F,G  '
new_name = name.startswith("A")
print("--->",new_name,"<---")
---> True <---
##############################
name = 'AB, CD, E, F,G  '
new_name = name.startswith("a")
print("--->",new_name,"<---")
---> False <---

8. 是否以什么结尾.endswith()

 name = 'AB, CD, E, F,G'
new_name = name.endswith("G")
print("--->",new_name,"<---")
---> True <---
##############################
name = 'AB, CD, E, F,G'
new_name = name.endswith("g")
print("--->",new_name,"<---")
---> False <---

9. 格式化输出.format()

 name = 'AB, CD, E, F,G,{}'
new_name = name.format("呵呵呵")
print("--->",new_name,"<---")
---> AB, CD, E, F,G,呵呵呵 <---

10.连接字符串.join()

 name = 'AB, CD, E, F,G'
new_name = "_".join(name)
print("--->",new_name,"<---")
---> A_B_,_ _C_D_,_ _E_,_ _F_,_G <---

11.统计次数.count()

 name = 'AB, CD, E, F,G,ABC,AC'
new_name = name.count("A")
print("--->",new_name,"<---")
---> 3 <---

12.指定编码格式.encode()

 name = 'ABCDEF'
new_name = name.encode("GBK")
print("--->",new_name,"<---")
---> b'ABCDEF' <---
#######################
name = 'ABCDEF'
new_name = name.encode("UTF-8")
print("--->",new_name,"<---")
---> b'ABCDEF' <---
######################
name = '努力'
new_name = name.encode("UTF-8")
print("--->",new_name,"<---")
---> b'\xe5\x8a\xaa\xe5\x8a\x9b' <---
######################
name = '努力'
new_name = name.encode("GBK")
print("--->",new_name,"<---")
---> b'\xc5\xac\xc1\xa6' <---

12.补足多少位

 s = '123'
print(s.rjust(8, "0")) # 00000123
print(s.ljust(8, "0")) # 12300000

3.4 列表(list)

列表是python的基础数据类型之一 ,它是以[ ]括起来, 每个元素用’ , ‘隔开而且可以存放各种数据类型:

比如：

 lis = ["alex", "WuSir", "ritian", "barry", "wenzhou"]

3.4.1. 列表的索引

列表也拥有索引:

 >>> lis = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
>>> print(lis[0])
alex
>>> print(lis[1])
WuSir
>>> print(lis[2])
ritian
>>> print(lis[3])
barry

3.4.2. 列表的切片

列表可以根据索引进行切片

 lis = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
>>> print(lis[0:3])
['alex', 'WuSir', 'ritian']
>>> print(lis[0:-1])
['alex', 'WuSir', 'ritian', 'barry']
>>> print(lis[1::2])
['WuSir', 'barry']
>>>

3.4.3 列表的嵌套

 >>> lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
>>> print(lis[3])
['qwe', 20, ['k1', ['tt', 3, '1']], 89]
>>> print(lis[3][2])
['k1', ['tt', 3, '1']]
>>> print(lis[3][2][0])
k1
>>> print(lis[3][2][1])
['tt', 3, '1']

3.4.4 列表方法详解

1.追加.append()

 user_list = ["alex","wusir","ritian","jing"]
user_list.append("摸摸哒")
print(user_list)
['alex', 'wusir', 'ritian', 'jing', '摸摸哒']

2.插入.insert()

 user_list = ["alex","wusir","ritian","jing"]
user_list.insert(0,"摸摸哒")
print(user_list)
['摸摸哒', 'alex', 'wusir', 'ritian', 'jing']

3.按索引删除.pop()

 user_list = ["alex","wusir","ritian","jing"]
user_list.pop(3)
print(user_list)
['alex', 'wusir', 'ritian']

4.按内容删除.remove()

 user_list = ["alex","wusir","ritian","jing"]
user_list.remove("alex")
print(user_list)
['wusir', 'ritian', 'jing']

5.清空列表.clear()

 user_list = ["alex","wusir","ritian","jing"]
user_list.clear()
print(user_list)
[]

6.del(按索引删除,可以切片删除)

 a = ['kngiht','kevin','qaz',1,2,3]
del a[2:4]
print(a)     #['kngiht', 'kevin', 2, 3] 按索引切片删除

7.迭代添加.extend ()

 user_list = ["alex","wusir","ritian","jing"]
user_list.extend(["摸摸哒","呵呵哒","佩琦"])
print(user_list)
['alex', 'wusir', 'ritian', 'jing', '摸摸哒', '呵呵哒', '佩琦']

8.反转列表内容.reverse()

 user_list = ["alex","wusir","ritian","jing"]
user_list.reverse()
print(user_list)
['jing', 'ritian', 'wusir', 'alex']

9.排序.sort()

 ## 正向排序
user_list = [1,2,3,4,5,5,6,5,4,3,2,16,100,20]
user_list.sort()
print(user_list)
[1, 2, 2, 3, 3, 4, 4, 5, 5, 5, 6, 16, 20, 100]
 
## 反向排序
user_list = [1,2,3,4,5,5,6,5,4,3,2,16,100,20]
user_list.sort(reverse=True)
print(user_list)
[100, 20, 16, 6, 5, 5, 5, 4, 4, 3, 3, 2, 2, 1]

3.5 元组（tuple）

不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改.

 >>> lis = ("alex", "WuSir", "ritian", "barry", "wenzhou")
>>>
>>> print(lis[0])
alex
>>> print(lis[1:4])
('WuSir', 'ritian', 'barry')
>>> print(lis[1:])
('WuSir', 'ritian', 'barry', 'wenzhou')
>>> print(lis[1:-1])
('WuSir', 'ritian', 'barry')
>>> print(lis[::-1])
('wenzhou', 'barry', 'ritian', 'WuSir', 'alex')
>>>

关于不可变, 注意: 这里元组的不可变的意思是子元素不可变. 而子元素内部的子元素是可以变, 这取决于子元素是否是可变对象.

元组中如果只有一个元素. 一定要添加一个逗号, 否则就不是元组

 >>> tup = ("keep")
>>> print(type(tup)) # type是查看数据类型
<class 'str'>
>>> tup = ("keep",)
>>> print(type(tup))
<class 'tuple'>

元祖嵌套

 >>> tu = ('今天姐姐不在家','姐夫和小姨子在客厅聊天',('姐夫问小姨子税后多少钱',' 小姨子低声说道说和姐夫还提钱'))
>>>
>>> print(tu1)
今天姐姐不在家
>>> print(tu2)
姐夫和小姨子在客厅聊天
>>> print(tu3)
姐夫问小姨子税后多少钱
>>> print(tu4)
小姨子低声说道说和姐夫还提钱

元组（不可变）

公共
- 索引
- 切片
- 步长
- for
- len

3.6 字典（dict）

字典(dict)是python中唯⼀的⼀个映射类型.他是以{ }括起来的键值对组成。 python3.6后字典是有序的

有序字典？如果想用怎么办？

 from collections import OrderedDict
 
info = OrderedDict()
info['k1'] = 123  #本质就是调用__setitem__
info['k2'] = 456
 
#info['k1']  #__getitem__
 
print(info.keys())
print(info.values())
print(info.items())

和列表list比较，字典dict有以下几个特点：

查找和插入的速度极快，不会随着key的增加而变慢；
需要占用大量的内存，内存浪费多。

而list相反：

查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。

在dict中key是唯⼀的.在保存的时候, 根据key来计算出⼀个内存地址. 然后将key-value保存在这个地址中，这种算法被称为hash算法。

可以改变的都是不可哈希的, 那么可哈希就意味着不可变. 这个是为了能准确的计算内存地址⽽规定的.

3.6.1 语法

 {'key1':1,'key2':2}

注意: key必须是不可变(可哈希)的. value没有要求.可以保存任意类型的数据

数据类型划分：可变数据类型,不可变数据类型

字典无序

 不可变数据类型：元组,bool,int str  -->可哈希
可变数据类型：list,dict,set      --> 不可哈希
dict key(键) 必须是不可变数据类型(可哈希)    value(值)：任意数据类型

3.6.2 字典方法

1.增加

 dic = {'age':18,'name':'jin','sex':'male',}
1.1
dic['hight']=180 # 没有键值对会新增
print(dic)#{'age': 18, 'name': 'jin', 'sex': 'male', 'hight': 180}
dic['age']=16 #如果有键，则值会覆盖
print(dic)#{'age': 16, 'name': 'jin', 'sex': 'male', 'hight': 180}
 
1.2
dic.setdefault('weight') #有键值对，不做任何改变，没有则添加
dic.setdefault('weight',150)
dic.setdefault('name','erge')
print(dic)#{'age': 16, 'name': 'jin', 'sex': 'male', 'hight': 180, 'weight': None}

2.删除

 2.1 pop
print(dic.pop('age'))#16   返回age对应的值
print(dic.pop('二哥',None)) #None  为了防止删除的时候没有要删除的键，而报错设置一个返回值，也可以是字符串'没有此键'
print(dic.pop('name',None)) #jin 删除有的键，即使设置了返回值None也不会返回，而是返回删除成功的值 jin
print(dic) #{'name': 'jin', 'sex': 'male', 'hight': 180, 'weight': None}
 
2.2 popitem
print(dic.popitem()) #随机删除一个元素，并把删除元素的键和值放在一个元组里返回:(key, value)。
#返回值 ('weight', None)
print(dic) #{'sex': 'male', 'hight': 180}
2.3 del
del dic['sex'] #del +键，按键来删除
print(dic) #{'hight': 180}
 
del dic #删除字典
print(dic)
 
2.4 clear 清空字典
dic.clear(dic)
print(dic)

3.更改

 3.1
dic['age']=16 #如果有键，则值会覆盖
 
3.2
dic = {'name':'zy','age':18,'sex':'male'}
dic2 = {'name':'alex','weight':'150'}
dic2.update(dic) #一样的键，值会覆盖，不一样的键,会新增
print(dic2) #{'name': 'zy', 'weight': '150', 'age': 18, 'sex': 'male'}

4.查询

 dic1 = {'name':'zy','age':18,'sex':'male',}
4.1
print(dic1.keys()) #dict_keys(['name', 'age', 'sex'])
print(dic1.values()) #dict_values(['zy', 18, 'male'])
print(dic1.items()) #dict_items([('name', 'zy'), ('age', 18), ('sex', 'male')])
 
 
print(dic1['name']) #返回值 zy
print(dic1['name1']) #会报错，找不到这个键 KeyError: 'name1'
4.2
#这时可以用dic1.get() 设置一个返回值  如下：
print(dic1.get('name1','没有这个键')) #没有这个键
 
用循环查询
for i in dic1: #dic1与dicdic1.keys()一样,只打印出键
    print(i)  #name age sex
 
for i in dic1.keys():  #name age sex
    print(i)
 
for i in dic1.values():
    print(i) #zy 18 male
 
for i in dic1.items():  #返回的是元组，元组里是键值对
    print(i) #('name', 'zy') ('age', 18) ('sex', 'male')

计算长度.len()

 dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
items_dic = dic.update({"悟空":"金箍棒"})
print(len(dic))
4

3.6.3 字典的嵌套

 >>> dic = {
...     'name':'汪峰',
...     'age':48,
...     'wife':[{'name':'国际章','age':38}],
...     'children':['第一个熊孩子','第二个熊孩子']
... }
>>>
>>>
>>> d1 = dic['wife'][0]['name']
>>> print(d1)
国际章
>>> d2 = dic['children']
>>> print(d2)
['第一个熊孩子', '第二个熊孩子']
>>> d3 = dic['children'][0]
>>> print(d3)
第一个熊孩子

3.7 集合（set）

set集合是python的⼀个基本数据类型. ⼀般不是很常⽤. set中的元素是不重复的.⽆序的.⾥⾯的元素必须是可hash的(不可变数据类型)

3.7.1集合的方法

1.添加.add()

 s1 = {"刘能", "赵四", "⽪⻓⼭"}
s1.add("蔡徐坤")
print(s1)
{'刘能', '蔡徐坤', '⽪⻓⼭', '赵四'}

2. 删除.discard()

 s1 = {"刘能", "赵四", "⽪⻓⼭"}
s1.discard("赵四")
print(s1)
{'刘能', '⽪⻓⼭'}

3.交集.intersection()

 s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s1.intersection(s2)
print(s)
{'⽪⻓⼭'}

4.并集.union()

 s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s1.union(s2)
print(s)
{'赵四', '冯乡⻓', '刘能', '⽪⻓⼭', '刘科⻓'}

5.差集.difference()

 s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s1.difference(s2)
print(s)
{'赵四', '刘能'}
 
##################
 
s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s2.difference(s1)
print(s)
{'冯乡⻓', '刘科⻓'}

6.反交集.symmetric_difference()

 s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
s = s2.symmetric_difference(s1)
print(s)
{'赵四', '刘能', '冯乡⻓', '刘科⻓'}

7.计算长度.len()

 s1 = {"刘能", "赵四", "⽪⻓⼭"}
print(len(s1)) #3

3.7.2 嵌套问题

 # 1. 列表/字典/集合(可变数据类型) -> 不能放在集合中、不能作为字典的key（unhashable）
# 数据类型划分：可变数据类型,不可变数据类型
# 不可变数据类型：元组,bool,int str  -->可哈希
# 可变数据类型：list,dict,set      --> 不可哈希
# info = {1, 2, 3, 4, True, "国风", None, (1, 2, 3)}
# print(info)
# 2. hash -> 哈希是怎么回事？
# 因为在内部会将值进行哈希算法并得到一个数值（对应内存地址），以后用于快速查找。
 
可使用的对象包括： 数字 、字符串、元组，不可使用hash函数的是 列表、字典。
hash的特征：hash值的计算过程是以依据这个值的特征计算的，这要求被hash的值必须固定，因此被hash的值必须不可变。
用途: 文件签名 、 md5加密 、 密码验证
# 3. 特殊情况
# info = {0, 2, 3, 4, False, "国风", None, (1, 2, 3)}  #False为0，与0重复
# print(info)
# info = {            
#     1:'alex',
#     True:'oldboy'
# }
# print(info)  #{1: 'oldboy'}

3.8 公共功能

len
索引
切片
步长
for循环

3.9 内存相关

3.9.1 id,查看内存地址

 >>> v1 = [11,22,33]
>>> v2 = [11,22,33]
>>> print(id(v1),id(v2)) # 比较两个变量的内存值
4472652360 4473773640	
# 对于 -5 ~ 256 的整数来说会有小地址池的概念，不会创建新的内存地址

 >>> v1 = "我，你，他，它，她"
>>> v2 = "我，你，他，它，她"
>>> print(id(v1),id(v2))
4473666128 4473665840

  # 赋值，就是把v2指向了v1的内存地址，所以他们的内存地址一样
>>> v1 = "我，你，他，它，她"
>>> v2 = v1 
>>> print(id(v1),id(v2))
4473666128 4473666128
 
# 重新赋值，v1的内存地址变了，但是v2的内存地址没变
>>> v1 = "我，你，他，它，她"
>>> v2 = v1    
>>> v1 = "我，你，他，它，她，天"   v1现在指向"我，你，他，它，她，天"的地址，v2还是原来的
>>> print(id(v1),id(v2))
4473665840 4473666128
>>> print(v2)
我，你，他，它，她

is，比较内存地址

 >>> v1 = {'k1':'v1','k2':[1,2,3]}
>>> v2 = {'k1':'v1','k2':[1,2,3]}
>>> result1 = v1 == v2
>>> result2 = v1 is v2
>>> print(result1)
True
>>> print(result2)
False

重要

is 和 == 的区别？

== 用于比较值是否相等。
is 用于比较内存地址是否相等。

PS：找到内存地址并在其中做操作和赋值不一样

赋值是重新开辟一块内存空间、可变数据类型

 #练习1(内部修改)
v1=[11,22,33]
v2=v1
v1.append(666)
print(v2) #含有666
 
#练习2(赋值)
v1=[11,22,33]
v2=v1
v1=[1,2,3,4] #此时v1重新赋值为[1,2,3,4]，v1=[11,22,33] 对应的内存地址被回收，只要有指向这个内存地址的，就不会被回收
print(v2) #[11,22,33]
 
#练习3(重新赋值) 
v1='alex'
v2=v1
v1='old boy'
print(v2) #'alex'
 
总结：可变数据类型列表/字典/集合 有内部修改和赋值
字符串等不可变的 只有重新赋值（不可在内部修改）
 
ps:
v=[1,2,3]
value=[11,22,v]
value[2]=666 #对value自己更改，v不会改变
print(v)  #[1, 2, 3]
 
v=[1,2,3]
value=[11,22,v]
value[2][0]=666 #对v里面修改，v会改变
print(v)  #[666, 2, 3]

python中有小数据池--缓存机制，节省内存

数字（-5-256）
简单的字符串 ‘ALEX’

 a=1
b=1
print(id(a),id(b)) #496846480 496846480  #理论上赋值，是重新开辟内存地址，但python中有缓存机制

3.10 深浅拷贝

浅拷贝：只拷贝第一层

深拷贝：拷贝所有数据（只针对可变数据类型）--- 重新拷贝意味着重新在内存中开辟一块空间

只有一层的深拷贝意义不大，重要的是对于嵌套

 1、int+str+bool/tuple 深浅拷贝是一样的（不可变数据类型，类似小数据池的概念）
 
v1='alex'
v2=copy.copy(v1)
v3=copy.deepcopy(v1)
print(id(v1),id(v3)) #11611168 11611168

 2、list+set+dict （可变数据类型）
深浅拷贝不一样的

总结

 浅拷贝:仅会拷贝a的框架的内存地址, 里面的任何子元素的内存地址都不会被拷贝.
深拷贝:不仅拷贝a的框架,而且会拷贝a里所有的可变元素的内存地址,注意不可变元素仍不可拷贝

3.11 类型转换

1.数字转字符串

 >>> v1 = 666
>>> v2 = str(v1)
>>> print (v2)
666

2.数字转布尔

 >>> v1 = 0
>>> v2 = bool(v1)
>>> print (v2)
False
#######################
>>> v1 = 666
>>> v2 = bool(v1)
>>> print (v2)
True

非零值转布尔都是True，0转布尔是False

3.字符串转数字

 >>> v1 = "666"
>>> v2 = int(v1)
>>> print (v2)
666
### 字符串内容是数字时，可以转换成数字
 
>>> v1 = "hello2"
>>> v2 = int(v1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'hello2'
###字符串含有数字以外的字符时，不能转换成数字
 
 
>>> v1 = ""
>>> v2 = int(v1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: ''
    
###空字符串不能转换成数字

4.字符串转布尔值

 >>> v1 = "66q3"
>>> v2 = bool(v1)
>>> print(v2)
True
### 非空字符串转换布尔值都是True
 
>>> v1 = ""
>>> v2 = bool(v1)
>>> print(v2)
False
### 空字符串转换布尔值是Fales

5.布尔值转换数字

 >>> v1 = True
>>> v2 = int(v1)
>>> print(v2)
1
 
>>> v1 = False
>>> v2 = int(v1)
>>> print(v2)
0

6.布尔值转换字符串

 >>> v1 = True
>>> v2 = str(v1)
>>> print(v2)
True
 
>>> v1 = False
>>> v2 = str(v1)
>>> print(v2)
False

posted @ 2019-09-12 11:45 hanfe1 阅读(269) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 上周热点回顾（2.24-3.2）

公告

长路漫漫唯剑作伴。

昵称： hanfe1
园龄： 6年11个月
粉丝： 67
关注： 30

+加关注

2025年3月

日

一

二

三

四

五

六

	>>> from __future__ import division
	>>> value = 3/2
	>>> print(value)
	1.5
	>>>
	>>> value = 10/3
	>>> print(value)
	3.33333333333

	>>> True
	True
	>>> 3 > 2
	True
	>>> False
	False
	>>> 3 > 5
	False
	>>> 30 > 66
	False
	>>> 444 > 333
	True
	>>>

	>>> a = "hello"
	>>> b = 5
	>>> print(a*b)
	hellohellohellohellohello

	>>> name = "ABCDE"
	>>> print(name[0])
	A
	>>> print(name[1])
	B
	>>> print(name[2])
	C
	>>> print(name[-1])
	E
	>>> print(name[-2])
	D
	>>> print(name[-0])
	A

	>>> name = "ABCDE"
	>>> print(name[:1])
	A
	>>> print(name[1:])
	BCDE
	>>> print(name[1:4])
	BCD
	>>> print(name[1:-1])
	BCD
	>>> print(name[1:-2])
	BC

	>>> name = "ABCDE"
	>>>
	>>> print(name[:1:2])
	A
	>>> print(name[::2])
	ACE
	>>> print(name[::-2]) # 负数就是倒着取
	ECA
	>>>

	s = 'alex Wusir' #首字母大写
	s1 = s.capitalize() #首字母大写# print(s1) #Alex wusir

	s3 = s.swapcase() #大小写翻转
	print(s3) #ALEX wUSIR

	a = 'zhangyang zy yy'
	a1 = a.title() #每个隔开的（特殊字符和数字）单词首字母大写
	print(a1) #Zhangyang Zy Yy

	>>> name = 'abcdef'
	>>> new_name = name.upper()
	>>> print(new_name)
	ABCDEF

	#######

	>>> name = 'ABCdef123'
	>>> new_name = name.upper()
	>>> print(new_name)
	ABCDEF123
	>>>
	##################
	v = 'ALEX'
	v1 = v.upper()
	print(v1)
	v2 = v.isupper() # 判断是否全部是大写
	print(v2)

	>>> name = 'ABCDEF'
	>>> new_name = name.lower()
	>>> print(new_name)
	abcdef

	################

	>>> name = 'ABCdef123'
	>>> new_name = name.lower()
	>>> print(new_name)
	abcdef123

	old -- 将被替换的子字符串。
	new -- 新字符串，用于替换old子字符串。
	max -- 可选字符串, 替换不超过 max 次

	message = input('请说话：')
	print(message)
	data = message.replace('大爷',"",2)# 将大爷替换成，替换不超过2次
	print(data)

	name = ' AB, CD, E, F, G '
	new_name = name.strip()
	print("--->",new_name,"<---")
	---> AB, CD, E, F, G <---

	name = ' AB, CD, E, F, G '
	new_name = name.lstrip()
	print("--->",new_name,"<---")
	---> AB, CD, E, F, G <---

	name = ' AB, CD, E, F, G '
	new_name = name.rstrip()
	print("--->",new_name,"<---")
	---> AB, CD, E, F, G <---

	>>> message = "小黑现在一脸懵逼，因为昨天晚上一直在学习，直到深夜。"
	>>> result = message.rsplit('，',1)
	>>> print(result)
	['小黑现在一脸懵逼，因为昨天晚上一直在学习', '直到深夜。']
	>>> result = message.rsplit('，')
	>>> print(result)
	['小黑现在一脸懵逼', '因为昨天晚上一直在学习', '直到深夜。']

	v = '1'
	# v = '二'
	# v = '②'
	v1 = v.isdigit() # '1'-> True; '二'-> False; '②' --> True
	v2 = v.isdecimal() # '1'-> True; '二'-> False; '②' --> False
	v3 = v.isnumeric() # '1'-> True; '二'-> True; '②' --> True
	print(v1,v2,v3)
	# 以后推荐用 isdecimal 判断是否是 10进制的数。

	# ############## 应用 ##############

	v = ['alex','eric','tony']

	for i in v:
	print(i)

	num = input('请输入序号：')
	if num.isdecimal():
	num = int(num)
	print(v[num])
	else:
	print('你输入的不是数字')

	name = 'AB, CD, E, F,G '
	new_name = name.startswith("A")
	print("--->",new_name,"<---")
	---> True <---
	##############################
	name = 'AB, CD, E, F,G '
	new_name = name.startswith("a")
	print("--->",new_name,"<---")
	---> False <---

	name = 'AB, CD, E, F,G'
	new_name = name.endswith("G")
	print("--->",new_name,"<---")
	---> True <---
	##############################
	name = 'AB, CD, E, F,G'
	new_name = name.endswith("g")
	print("--->",new_name,"<---")
	---> False <---

	name = 'AB, CD, E, F,G,{}'
	new_name = name.format("呵呵呵")
	print("--->",new_name,"<---")
	---> AB, CD, E, F,G,呵呵呵 <---

	name = 'AB, CD, E, F,G'
	new_name = "_".join(name)
	print("--->",new_name,"<---")
	---> A_B_,_ _C_D_,_ _E_,_ _F_,_G <---

第三章数据类型