---

前言

什么是数据类型？

我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型包括多种，数字类型Number（int 、float 、 complex 、 bool），字符串类型（str），列表类型（list），集合类型（set），字典类型（dict）。

---

一、python的基础数据类型

数字类型（Number）

整型 （int）

在64位系统上，整数的位数为64位，取值范围为-263～263-1，即-9223372036854775808～9223372036854775807
例如：
定义一个整型

intvar = 10
print(intvar)
# 结果
>>>>> 10

用type查看intvar的类型

intvar = 10
print(type(intvar))
# 结果
>>>>> <class 'int'>

使用id获取内存地址

print(id(intvar))
# 结果
>>>>> 1962700080

浮点型（float）

浮点型=小数类型
方作为变量赋值时默认保留15位小数，且不会四舍五入

floatvar = 10.15
print(floatvar,type(floatvar))
# 结果
>>>>> 10.15 <class 'float'>floatvar = 10.1555513312432155
print(floatvar,type(floatvar))
# 结果
>>>>> 10.155551331243215 <class 'float'>

当float在变量的格式化输出，使用 %-string格式化 时默认是6位小数位数

a = float(6)
print('%f'%(a))
# 结果
>>>>> 6.000000

当然你也可以自定义保留位数
.2f 就相当于保留2位小数

a = float(6)
print('%.2f'%(a))
# 结果
>>>>> 6.00

其他运算或格式化输出都是默认一位小数，其中有更多位数，就取最大位数

a = float(6)
b = float(3)
c =a+b
print(c)
# 结果
>>>>> 9.21a = float(6)
b = float(3)
print("{},{}".format(a,b))
# 结果
>>>>> 6.0,3.0

另外format还有四舍五入的功能，可以自己试一下

复数型（complex）

complex 实数 + 虚数
1+2j
1: 实数
2j: 虚数
j: 如果有一个数,他的平方等于-1,那么这个数就是j,表达的是高精度的类型

complexvar = 1-2j
print(complexvar)
print(type(complexvar))
# 结果
# (1-2j)
# <class 'complex'>complexvar = -2j
print(complexvar)
print(type(complexvar))
# 结果
# (-0-2j)
# <class 'complex'>

布尔类型（bool）

布尔类型只有True 真 False 假 两个值，一般是在判断或循环中使用

boolvar = True
boolvar = False
print(boolvar)
print(type(boolvar))

数学函数

abs(x)   返回数字的绝对值，如abs(-10) 返回 10ceil(x)  返回数字的上入整数，如math.ceil(4.1) 返回 5cmp(x, y)如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃 。使用 使用 (x>y)-(x<y) 替换。exp(x)    返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0floor(x)  返回数字的下舍整数，如math.floor(4.9)返回 4log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0log10(x)    返回以10为基数的x的对数，如math.log10(100)返回 2.0max(x1, x2,...)  返回给定参数的最大值，参数可以为序列。min(x1, x2,...)   返回给定参数的最小值，参数可以为序列。modf(x)   返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。pow(x, y)   x**y 运算后的值。round(x [,n])    返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。sqrt(x)  返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j

三角函数

acos(x)  返回x的反余弦弧度值。asin(x)  返回x的反正弦弧度值。 atan(x) 返回x的反正切弧度值。atan2(y, x)  返回给定的 X 及 Y 坐标值的反正切值。cos(x) 返回x的弧度的余弦值。hypot(x, y)  返回欧几里德范数 sqrt(x*x + y*y)。sin(x)    返回的x弧度的正弦值。tan(x)   返回x弧度的正切值。degrees(x)    将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0radians(x)  将角度转换为弧度

数学常量

pi   数学常量 pi（圆周率，一般以π来表示）
e   数学常量 e，e即自然常数（自然常数）。

小数据池

id   => id是内存地址is    => 比较两边的内存是否相等==  => 比较两边的数值是否相等=    => 是赋值

小数据池的缓存机制

小数据池，也称为小整数缓存机制，或者称为驻留机制等等，对于数字: -5~256是会被加到⼩小数据池中的. 每次使⽤用都是同⼀一个对象.对于字符串串:1.如果字符串串的长度是0或者1, 都会默认进行缓存2.字符串长度大于1, 但是字符串中只包含字母, 数字, 下划线时才会缓存3.用乘法的到的字符串乘数为1, 仅包含数字,字母,下划线时会被缓存. 如果
包含其他字符, 而长度<=1 也会被驻存,乘数大于1 . 仅包含数字, 字母, 下划
线这个时候会被缓存. 但字符串串长度不能大于204.指定驻留留. 我们可以通过sys模块中的intern()函数来指定要驻留留的内容.

字符串类型（str ''或""）

概念

定义：用 " " 、’ ’ 、’’’ ‘’'或者""" “”"。中间包含的部分称之为字符串
PS：即使里面写入的是数字，那么他的数据类型也是字符串
特性：
1.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序
2.可以进行切片操作
3.不可变，字符串是不可变的，不能像列表一样修改其中某个元素，所有对字符串的修改操作其实都是相当于生成了一份新数据。

补充：
1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r’l\thf’

字符串的用法

# 单引号的字符串
a = '11111'
# 双引号的字符串
b = "abc"
print(a,b,type(a),type(b))
# 结果
>>>>> 11111 abc <class 'str'> <class 'str'>

三引号的字符串，支持跨行效果

strvar = """
醉里挑灯看剑，
梦回吹角连营。
八百里分麾下炙，
五十弦翻塞外声，
沙场秋点兵。
"""
print(strvar,type(strvar))
# 结果
>>>>>
醉里挑灯看剑，
梦回吹角连营。
八百里分麾下炙，
五十弦翻塞外声，
沙场秋点兵。<class 'str'>

转义字符

\ + 某个字符
(1) 将有意义的字符变得无意义
(2) 将无意义的字符变得有意义
\n 和 \r\n : 换行
\t : Tab缩进(水平制表符)（一般来说,一个锁进是4个空格的距离）
\r : 将后面的字符直接拉到当前行行首

元字符串

r"字符串" 不转义字符,原型化输出字符串

strvar = r"E:\npython31\tay2"
print(strvar)
# 结果
>>>>> E:\npython31\tay2 <class 'str'>

格式化字符串

语法 : “字符串” % (值1,值2,值3)
%d 整型占位符
%2d 占两位 原字符串默认居右

strvar = "我今年%2d岁" % (2)
print(strvar)
# 结果
>>>>> 我今年 2岁

%-2d 占两位 原字符串默认居左(一般没什么用)

strvar = "白星公主今年%-2d岁" % (200)
print(strvar)

%f 浮点型占位符
%.2f 小数点保留2位
%f 存在四舍五入的情况

strvar = "%.2f" % (2.566)
print(strvar)
# 结果
>>>>> 2.57

%s 字符串占位符

a = "星期六"
b = "星期天"
c = 12
d = 1.5
e = 3.1415926
strvar = "今天是%s，明天是%s，%d,%f,%.2f" % (a,b,c,d,e)
print(strvar)
# 结果
>>>>> 今天是星期六，明天是星期天，12,1.500000,3.14

使用format格式化字符串

# 1.顺序传参
strvar = "{}喜欢吃{}".format("我","苹果")
print(strvar)# 2.索引传参
strvar = "{1}喜欢吃{0}".format("苹果","我")
print(strvar)# 3.关键字传参
strvar = "{thing2}喜欢吃{thing1}".format(thing1="苹果",thing2="我")
print(strvar)# 4.容器类型数据(列表或元组传参)
strvar = "{0[2]}喜欢吃{1[1]}".format(["小红","小明","小刚"],("苹果","香蕉","菠萝"))
print(strvar)# format当中，不能使用逆向下标，不识别
# strvar = "{0[-1]}喜欢吃{1[-1]}".format(["小红","小明","小刚"],("苹果","香蕉","菠萝"))
# print(strvar)# 如果容器是字典
strvar="{group1[xiaoming]}喜欢吃{group2[0]}".format(group1={"xiaohong":"小红","xiaoming":"小明"},group2=("香蕉","苹果"))
print(strvar)

format 填充符号的使用和转换成特殊符号的使用

#  format的填充符号的使用(^ < >)
"""
^ 原字符串居中
< 原字符串居左
> 原字符串居右{who:*^10}
who:关键字参数
*:要填充的字符
^:原字符串居中
10:总长度=原字符串长度+填充字符长度
"""strvar = "{who:*^10}在{where:>>10}吃{what:!<10}".format(who="我",where="别人家",what="苹果")
print(strvar)# 进制转换成特殊符号的使用( :d :f :s :,)# :d 整型占位符 要求类型必须是整型
strvar = "我吃了{:d}个苹果".format(3) #3.5 error
# :2d 占用两位，不够拿空格来补，默认居右
strvar = "我吃了{:2d}个苹果".format(3)
#  < > ^ 调整对应的位置
strvar = "我吃了{:<2d}个苹果".format(3)
strvar = "我吃了{:<3d}个苹果".format(3)
print(strvar)# :f 浮点型占位符(要求类型必须是浮点型)
strvar = "我的成绩是{:f}".format(96.25)
# .2f 小数点保留两位
strvar = "我的成绩是{:.2f}".format(96.25)
print(strvar)# :s 字符串占位符 (要求类型必须是字符串)
strvar = "{:s}".format("啦啦啦啦啦")
print(strvar)# :, 金钱占位符
strvar = "{:,}".format(3256224583)
print(strvar)# 综合案例
strvar = "我今年{:d}岁,我的语文分数是{:.1f},我心情{:s}".format(23,98.65,"非常好")
print(strvar)

字符串的相关操作

1.字符串的拼接

strvar = 'abc' + 'def'
print(strvar)
# 输出：abcdef

2.字符串重复

strvar = 'qwer' * 3
print(strvar)
# 输出：qwerqwerqwer

3.字符串的跨行拼接

strvar = 'qwer' \
'ert'
print(strvar)
# 输出：qwerert

4.字符串的索引

正向索引 0123
strvar = "1234"
逆向索引 -4-3-2-1

5.字符串的切片
注意: [开始索引:结束索引:间隔值]
res = strvar[::2] # 0 2 4 6 8… 从开始截取到最后
res = strvar[::-1] # -1 -2 -3 -4 -5 -6… 从结尾截取到最前

# [开始索引:]  从开始索引截取到字符串的最后
strvar="红橙黄绿青蓝紫"
res = strvar[4:]
print(res) # [:结束索引]  从开头截取到结束索引之前(结束索引-1)
res = strvar[:5]
print(res)# [开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
res = strvar[1:3]
print(res)# [开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取字符
# 正序
res = strvar[::2] # 0 2 4 6 8..... 从开始截取到最后
print(res)
# 倒序
res = strvar[::-1] # -1 -2 -3 -4 -5 -6.....
print(res)# [:]或[::]  截取所有字符串
res1 = strvar[:]
res2 = strvar[::]
print(res1)
print(res2)

字符串的相关函数

常规：

# capicalize 字符串首字母大写
strvar ="what is your name"
res = strvar.capitalize()
print(res) # What is your name# title 每个单词的首字母大写
strvar ="what is your name"
res = strvar.title()
print(res) # What Is Your Name# upper 将所有字母变成大写
strvar ="what is your name"
res = strvar.upper()
print(res) # WHAT IS YOUR NAME# lower 将所有字母变成小写
strvar = "HELLO KITTY"
res = strvar.lower()
print(res) # hello kitty# swapcase 大小写互换
strvar = "AAAAbbbb"
res = strvar.lower()
print(res) # aaaaBBBB# len 计算字符串的长度
strvar = "AAAAbbbb"
res = len(strvar)
print(res) # 8# count 统计字符串中某个元素的数量
strvar = "AAAAbbbb"
res = strvar.count("A")
print(res) # 4# find  查找某个字符串第一次出现的索引位置(推荐使用)
'''字符串.find("字符",开始索引,结束索引) 如果找不到直接返回-1'''
strvar = "abcdefabc"
res = strvar.find("a") # 0
res = strvar.find("a",2) # 6
res = strvar.find("d",2,5) # 3 结束索引本身取不到，取到之前的那个值
print(res)# index与find功能相同，find找不到返回-1，index找不到数据会报错
res = strvar.index("d",6,8) # error# startswith 判断是否以某个字符或字符串为开头
'''
字符串.startswith("字符串",开始索引,结束索引)
如果存在返回True，否则返回False
'''
strvar = "abcdefg"
res = strvar.startswith("a") # True
res = strvar.startswith("b",1) # True
res = strvar.startswith("c",2,5) # True  2 3 4
print(res)# endswith 判断是否以某个字符或字符串结尾
res = strvar.endswith("g") # True
res = strvar.endswith("g",-6) # True
res = strvar.endswith("d",-6,-3) # Trueprint(res)

is判断类

# isupper 判断字符串是否都是大写字母
strvar = "ABCD"
res = strvar.isupper()
print(res) # True# islower 判断字符串是否都是小写字母
strvar = "abcd123"
res = strvar.isupper()
print(res) # True# isdecimal 检测字符串是否以数字组成 必须是纯数字
strvar = "12345"
strvar = "123.4567"
res = strvar.isdecimal()
print(res)

填充/去除

strvar = "abc"
# ljust 填充字符串，原字符居左(默认填充空格)
res = strvar.ljust(10)
print(res)
# rjust 填充字符串，原字符居右(默认填充空格)
res = strvar.rjust(10)
print(res)
# center 填充字符串，原字符居中(默认填充空格)
res = strvar.center(10) # 原字符串长度+填充字符长度=10，默认填充空格
res = strvar.center(10,"#")
print(res)# strip 默认去掉首尾两边的空白符
strvar = "####abcd####"
res = strvar.strip("#") # 指定去掉的符号
print(res)
# rstrip 去掉右边某个字符
print(strvar.rstrip("#"))
# rstrip 去掉左边某个字符
print(strvar.lstrip("#"))

字符串常用的三个方法（重要）

# split 按某字符将字符串分割成列表(默认字符是空格)
strvar = "one two three four"
lst = strvar.split()
strvar= "one-two-three-four"
lst = strvar.split("-") # 从左到右分隔
lst = strvar.rsplit("-",2) # 从右到左分隔，可以指定分隔的次数
print(lst)# join 按某字符将列表拼接成字符串
lst = ['five','six','seven','eight']
res = "-".join(lst)
print(res)# replace 替换，把字符串的旧字符替换成新字符
'''replace(要替换的字符,替换成什么,替换的次数)'''
strvar = "这只小狗真可爱，真呀真可爱"
res = strvar.replace("可爱","有趣")
res = strvar.replace("可爱","有趣",1) # 只替换一次
print(res)

列表类型（list[]）

概念

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如
定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素

特性：
1.可存放多个值
2.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序
3.可修改指定索引位置对应的值，可变

li = ['alex',123,True,(1,2,3,'wusir'),[1,2,3,'小明',],{'name':'alex'}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

列表的操作

# 1.列表的拼接(同元组)
lst1 = [1,2,3]
lst2 = [4,5,6,7,8,8]
res = lst1 + lst2
print(res)# 2.列表的重复(同元组)
res = lst1 * 6
print(res)# 3.列表的切片(同元组)
# 语法:列表[::]  完整格式：[开始索引:结束索引:间隔值]# (1)[开始索引:]  从开始索引截取到列表的最后# (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)# (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)# (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值# (5)[:]或[::]  截取所有列表lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]
# (1) [开始索引:]  从开始索引截取到列表的最后
res = lst[3:]
print(res)
# (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
res = lst[:6]
print(res)
# (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
res = lst[3:6]
print(res)
# (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
# 正向截取
res = lst[::2]
print(res)
# 逆向截取
res = lst[::-2]
print(res)
# (5)[:]或[::]  截取所有列表
res = lst[:]
res = lst[::]
print(res)# 4.列表的获取(同元组)
#      0      1     2       3       4       5      6      7
lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]
#      -8    -7    -6      -5       -4     -3     -2      -1res = lst[6]
res = lst[-2]
print(res)    # 5.列表的修改(可切片)
'''
要求的数据类型是:可迭代性数据(容器类型数据,range对象,迭代器)
'''lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]
# 利用切片可以一次修改多个元素，没有个数上的限制
lst[1:3] = "abcdef"
print(lst)# 切片配合步长,切出多少个元素，修改多少个元素
lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]
res = lst[::2] # Alan Sun Huahai Orange
lst[::2] = range(1,5)
print(lst)# 6.列表的删除
lst=["Alan","Cat","Sun","Wuming","Huahai","Mc","Orange","Rxy"]
del lst[-1]
print(lst)# 删除的是变量res本身，不是列表中的元素
'''
res = lst[-1]
del res
print(lst)
'''# del lst[:2]
del lst[::3] #0 3 6 9 12...
print(lst)# 元组中的列表,里面的元素可以修改;
tup = (1,2,3,[4,5,6,(7,8,9)])
tup[-1][1] = 66
print(tup)

列表的相关函数（增删及其他函数）

增
增 append insert extend（重点）

# append 向列表末尾添加新元素li = [6,8,7,5,8]li.append(2)                # 追加在最后 原来值在后面追加，因此不用赋予新的值print(li)
# insert 向指定索引位置进行追加li = [6,8,7,5,8]li.insert(2,"b")　　　　　　　# 前面参数指定索引，逗号分隔，加要插入的元素print(li)
# extend 扩展原列表，参数可迭代对象（数字不能扩展，数字不可迭代）li = [6,8,7,5,8]li.extend("b")              # 扩展追加。print(li)

删
删 pop remove clear（重点）

# pop 通过索引删除某个值，无索引则默认删除最后一个值，赋予一个值也可以获得被删除的值li = [6,8,7,5,8]v = li.pop(2)               # 指定索引删除，无索引则默认删除最后一个值，也可以获取删除的值print(li)print(v)
# remove　　删除列表指定值，左边优先li = [6,8,7,5,8]li.remove(8)                # 删除列表指定值，从左优先print(li)
# clear　　 清空列表li = [6,8,7,5,8]li.clear()                  # 清空列表print(li)

其他函数
其他函数 index count sort reverse

lst=["Fly","Fly","Fly","Fly","Hurt","Cat","Alan","Yang"]# index 获取某个值在列表中的索引
'''列表.index(值,[,start],[,end]) 表达参数可选项 找不到报错'''
res = lst.index("Hurt")
res = lst.index("Hurt",3)
res = lst.index("Hurt",2,4)
print(res)# count 计算某个元素出现的次数
res = lst.count("Fly")
print(res)
'''
注意：字符串里的count可以划定范围，列表里面的count不行
'''
strvar = "aaaaabcdefg"
res = strvar.count("a",1,6)
print(res)# sort() 列表排序(默认小到大排序)
# 默认从小到大
lst=[3,8,26,9,-25,-1,7]
lst.sort()
# 从小到大排序
lst.sort(reverse=True)
print(lst)
# 排序英文------> ASCII编码
'''一位一位进行比较，在第一次相同的情况下，比较第二位，以此类推'''
lst=["Cow","Fly","Hurt","Cat","Alan","Yang"]
lst.sort()
print(lst)
# 也可以对中文排序-------> 但是无规律可循
lst = ["王添龙","陈正正","夏圣钦","万潇阳","彭云飞"]
lst.sort()
print(lst)# reverse() 列表反转操作
lst = ["王添龙","陈正正","夏圣钦","万潇阳","彭云飞"]
lst.reverse()
print(lst)

深浅拷贝

概念

copy浅拷贝，没有拷贝子对象，所以原始数据改变，子对象会改变深拷贝，包含对象里面的自对象的拷贝，所以原始对象的改变不会造成深拷贝里任何子元素的改变

浅拷贝

# 1.浅拷贝
import copy
lst1=[1,2,3]# 方法一：copy.copy 模块.方法
lst2 = copy.copy(lst1)
lst1.append(4)
print(lst1) #[1, 2, 3, 4]
print(lst2) #[1, 2, 3]# 方法二：列表.copy()
lst1 = [1,2,3,4]
lst3 = lst1.copy()
lst1.insert(0,0)
print(lst1) # [0, 1, 2, 3, 4]
print(lst3) # [1, 2, 3, 4]

深拷贝

# 引入深拷贝(浅拷贝无法满足需求)
lst1 = [1,2,3,[4,5,6]]
lst2 = copy.copy(lst1)
lst1[-1].append(7)
lst1.append(100)
print(lst1) # [1, 2, 3, [4, 5, 6, 7], 100]
print(lst2) # [1, 2, 3, [4, 5, 6, 7]]# deepcopy 深拷贝
import copy
lst3 = [1,2,3,[4,5,6]]
lst4 = copy.deepcopy(lst3)
lst4[-1].append(0)
print(lst4) # [1, 2, 3, [4, 5, 6, 0]]
print(lst3) # [1, 2, 3, [4, 5, 6]]print(id(lst2[-1])) # 2731177062472
print(id(lst1[-1])) # 2731177036872print(id(lst1[0])) # 1347321968
print(id(lst2[0])) # 1347321968lst2[0] = 11
print(id(lst1[0])) # 1347321968
print(id(lst2[0])) # 2390383439568

深浅拷贝的总结

1.浅拷贝只拷贝一级容器中的所有数据
2.深拷贝拷贝所有层级的所有元素浅拷贝速度比深拷贝速度快
深拷贝在执行时: 如果是不可变数据,地址会暂时的指向原来数据,
如果是可变数据,直接开辟新空间
不可变数据: Number str tuple
可变数据 : list set dict

元组类型（tupe())

概念

元组是对列表的二次加工，书写格式为括号（），在里面放元组的元素不可被修改，且不能被增加和删除元组中的元素，所以元组又被称为只读列表，不能修改。只有特定情况下可修改

定义：与列表类似，只不过［］改成（）
特性：
　　1.可存放多个值
　　2.不可变
　　3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

元组的常用操作

索引切片

tu = (1,2,'alex','oldboy')
#切片
print(tu[:2])
#指定索引取值
print(tu[2])

遍历元组

tu = (1,2,'alex','oldboy')
for i in tu:print(i)

注意：元组本身不可变，如果元组中还包含其他可变元素，这些可变元素可以改变

tu = (1,2,'alex',[1,'taibai'],'oldboy')
tu[3].append('yuhuang')
print(tu)

上面这段代码是因为元组只是存每个元素的内存地址，[1,‘taibai’]这个列表本身的内存地址存在元组里确实不可变，但是这个列表包含的元素的内存地址是存在另外一块空间里的，是可变的。

元组的运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
例如:

print(len((1, 2, 3,))) 结果为 3(1, 2, 3) + (4, 5, 6)   结果为 (1, 2, 3, 4, 5, 6)('Hi!',) * 4    结果为 ('Hi!', 'Hi!', 'Hi!', 'Hi!')3 in (1, 2, 3)  结果为 Truefor x in (1, 2, 3): print(x)    结果为 1 2 3

元组的相关方法

len(tuple)   计算元祖个数max(tuple)    返回元祖中元素最大值min(tuple)    返回元祖中元素最小值tuple(seq)    将列表转换为元祖

字典类型（dict{}）

概念

定义：｛key1:value1,key2:value2｝（语法）
1、键与值用冒号“：”分开；
2、项与项用逗号“，”分开；
示例：

dic = {'name':'李四','age':17,'name_list':['张三','李四'],
}
print(dic['name']) # 输出：李四
print(dic['name_list']) # 输出：['张三', '李四']

特性：
1.key-value结构

2.key必须为不可变数据类型、必须唯一

3.可存放任意多个value、可修改、可以不唯一

4.无序

5.查询速度快，且不受dict的大小影响

补充：
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。
存储大量的数据，是关系型数据，查询数据快。
列表是从头遍历到尾
字典使用二分查找
二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。
比如字典有1～100的数据，现在想要查找75。
先劈一半，找到中间值50。判断50和75的大小，发现小于，再劈一半。
找到中间值75，直接返回结果。

对于字符串查找
每一个字符串，都有一个hash值，是唯一的。

print(hash('a'))
# 输出：977260134378667761print(hash('afdsfeye'))
# 输出：6608581710363481317

字典的相关方法

增（fromkeys）

# dic[键]=值
dic={}
dic["Top"] = "Fly"
dic["Mid"] = "Mojo"
dic["Support"] = "Snow"
print(dic)
# 输出：{'Top': 'Fly', 'Mid': 'Mojo', 'Support': 'Snow'}# fromkeys() 使用一组键和默认值创建字典
lst=["Top","Jungle","Bottom"]
dic={}.fromkeys(lst,None)
print(dic)
# 输出：{'Top': None, 'Jungle': None, 'Bottom': None}# 注意点：三个键所指向的列表是同一个(不推荐)
'''dic = {}.fromkeys(lst,[])'''

删（pop popitem clear）

# pop() 通过键去删除键值对(若没有该键可设置默认值,预防报错)
dic={"Top":"Fly","Bottom":"Hurt","Jungle":"Giao","Mid":"Mojo","Support":"Snow"}
res = dic.pop("Top")
# 1.如果删除的是不存在的键，直接报错
res = dic.pop("King")
# 2.可以设置默认值，防止报错
res = dic.pop("King","没有这个键")
print(res)# popitem() 删除最后一个键值对
res = dic.popitem()
print(res,dic)# clear() 清空字典
dic.clear()
print(dic)

改（update）

# update() 批量更新(有该键就更新,没该键就添加)
dic1={"Top":"Fly","Bottom":"Hurt","Jungle":"Giao"}
dic2={"Top":"JieJ","Support":"770","Jungle":"Giao"}# 方法一(推荐)
dic1.update(dic2)
print(dic1)# 方法二
dic1.update(coach="SK",teacher="Bao")
print(dic1)

查（get）

#get() 通过键获取值(若没有该键可设置默认值,预防报错)
dic={"Top":"Fly","Bottom":"Hurt","Jungle":"Giao"}
res = dic.get("Top")
res = dic.get("Coach")
res = dic.get("Coach","没有这个键")
print(res)

其他函数（keys values items）重要

dic={"Top":"Fly","Bottom":"Hurt","Jungle":"Giao"}
#keys()   将字典的键组成新的可迭代对象
res = dic.keys()
print(res)#values() 将字典中的值组成新的可迭代对象
res = dic.values()
print(res)#items()  将字典的键值对凑成一个个元组,组成新的可迭代对象
res = dic.items()
print(res)

集合类型（set{}）

概念

定义
集合跟我们学的列表有点像，也是可以存一堆数据，不过它有几个独特的特点，令其在整个Python语言中占有一席之地，

1.里面的元素不可变，代表你不能存一个list、dict 在集合里，字符串、数字、元组等不可变类型可以存

2.天生去重，在集合里没办法存重复的元素

3.无序，不像列表一样通过索引来标记在列表中的位置 ，元素是无序的，集合中的元素没有先后之分，如集合{3,4,5}和{3,5,4}算作同一个集合

集合的相关操作

基本数据类型特点（可变：列表，字典 　　不可变：字符串，数字，元组）
集合中的元素必须是不可变类型，加入可变的类型会报错

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}print(student)   # 输出集合，重复的元素被自动去掉# 成员测试
if('Rose' in student) :print('Rose 在集合中')
else :print('Rose 不在集合中')

集合的运算（重要）

set1={"Chuchen","Yinuo","JiuC","Cat"}
set2={"15sui","SK","Dgc","Cat"}# 交集简写 &
res = sey1 & set2
print(res)# 差集简写 -
res = set1 - set2
print(res)# 并集简写 |
res = set1 | set2
print(res)# 对称差集简写 ^
res = set1 ^ set2
print(res)# 判断是否是子集简写 <
res = set1 < set2
print(res)# 判断是否是父集简写 >
res = set1 > set2
print(res)

集合的相关函数

增（add update）

# add　　添加，添加可变的数据类型也是会报错的
s = {1,2,5,5,'g','h'}
s.add(3)
print(s)# update() 迭代着增加 (一次加一堆)
strvar = ("Ache","Yuyu")
setvar.update(strvar)
print(setvar)

删（clear pop remove discard ）

set2 = {"Fly","JieJ","Rxy"}
# clear() 清空集合
set2.clear()# pop() 随机删除集合中的一个数据
res = set2.pop()
print(res,set2)# remove() 删除集合中指定的值(不存在则报错)(了解)
setvar.remove("Fly")
print(setvar)# discard() 删除集合中指定的值(不存在的不删除)(推荐使用)
set2.discard("Fly")
set2.discard("Sehah")
print(set2)

其他

set1={"Chuchen","Yinuo","JiuC","Cat"}
set2={"15sui","SK","Dgc","Cat"}# intersaction() 交集
res = set1.intersaction(set2)
print(res)#difference() 差集
res = set1.difference(set2)
print(res)#union() 并集
res = set1.union(set2)
print(res)#symmetric_difference() 对称差集 (补集情况涵盖在其中)
res = set1.symmetric_difference(set2)
print(res)#issubset() 判断是否是子集
set1 = {"Fly","JieJ","Nuoyan","Orange"}
set2 = {"Fly","JieJ"}
res = set1.issubset(set2)#issuperset() 判断是否是父集
res = set1.issuperset(set2)
print(res)#isdisjoint() 检测两集合是否不相交  不相交为True  相交为False
res = set1.isdisjoint(set2)
print(res)

冰冻集合

冰冻集合/固定集合：一旦创建就不可以进行修改的集合。一种数据类型。如果把集合比作列表，冰冻集合就是元组。

冰冻集合的作用：
为集合的操作提供一个不可以改变的对照集合。
冰冻集合除了不能修改之外，其余和集合一样！

copy()  可以使用
difference() 差集  可以使用
difference_update() 更新差集  不可以使用
intersection() 交集  可以使用
intersection_update()更新交集  不可以使用
union() 并集  可以使用
update()更新并集  不可以使用
issuperset()  检测超集  可以使用
issubset() 检测子集  可以使用
isdisjoint() 检测是否不相交  可以使用
symmetric_difference()可以使用（对称差集）
symmetric_difference_update()不可以使用（更新对称差集）

# frozenset 可强转容器类型数据变为冰冻集合
lst1 = ["Fly","Mojo","Hurt","770"]
fz1 = frozenset(lst1)
lst2 = ("Amy","Mike","Lucy")
fz2 = frozenset(lst2)
print(fz1 , type(fz1))
print(fz2 , type(fz2))# 不能够在冰冻集合当中添加或者删除元素
fz1.add("Marry") # error# 只能交差并补
print(fz1 & fz2)
print(fz1 - fz2)

强制类型转换和自动类型转换

Number类型强制转换（int、float、bool、complex）

整型 int

float可以转化成intbool可以转化成intstr(形如"123")可以转化成intcomplex不可以转化成intstr(形如"abc123")不可以转化成int

浮点型 float

int可以转化成floatbool可以转化成floatstr(形如"123")可以转化成float

布尔型 bool

bool类型为假的十种情况：0,  0.0，  False，   0j，   '',   [],   {},   (),  set(),   NoneNone 是python的关键字,代表空的,什么也没有,一般用来做初始化操作

复数型 complex

int可以转化成complexfloat可以转化成complexbool可以转化成complexstr(形如"123")可以转化成complexstr(形如"abc123")不可以转化成complex

Number自动类型转换

精度从低向高进行转换 : bool -> int -> float -> complex自动类型转换,默认从低精度向高精度进行转换(从低到高)可以实现以下几种自动类型转换：1.bool+int2.bool+float3.bool+complex4.int+float5.int+complex6.float+complex

容器类型的强制转换（str、list、tuple、set、dict）

字符串类型 str

所有容器和Number，str都可以强制转换成功强转成字符串,无非就是在原有的数据的基础上两边套上引号repr()作用： 可以原型化输出字符串,不转义字符(显示出引号)

列表类型 list

1.如果是字符串,会把每一个字符单独的作为一个元素放到列表中2.如果是字典,只保留键,形成一套新的列表3.如果是其他的容器,只是单纯的在原有数据的基础上换上[]

元组类型 tuple

1.如果是字符串,会把每一个字符单独的作为一个元素放到元组中2.如果是字典,只保留键,形成一套新的元组3.如果是其他的容器,只是单纯的在原有数据的基础上换上()

集合类型 set

1.如果是字符串,会把每一个字符单独的作为一个元素放到集合中(无序,自动去重)2.如果是字典,只保留键,形成一套新的集合3.如果是其他的容器,只是单纯的在原有数据的基础上换上{}

字典类型 dict

1.二级容器：包括二级列表，二级元组，二级集合，二级字典。
2.多级容器：3.4.5.6或更高级的容器，获取里面的值如下所示。

# 五级容器
container = [10,20,(1,2,3,{"a":1,"b":{"c":2,"d":[3,4,"success "]}})]
# 获取success
res1 = container[-1]
print(res1) # (1,2,3,,{"a":1,"b":{"c":2,"d":[3,4,"success "]}}res2 = res1[-1]
print(res2) # {"a":1,"b":{"c":2,"d":[3,4,"success "]}}res3 = res2["b"]
print(res3) # {"c":2,"d":[3,4,"success "]}res4 = res3["d"]
print(res4) # [3,4,"success "]res5 = res4[-1]
print(res5) # success# 五步合成一步
res = container[-1][-1]["b"]["d"][-1]
print(res) # success

3.等长的二级容器：里面的元素都是容器,并且容器里面的元素个数都相同，如下

lst = [(1,2,3) , [4,5,6]]
lst = [(1,2) , [3,4]]

4.dict 强制转换成字典：强转成字典时 , 必须是等长的二级容器,里面的元素个数是2个，如下

1.外层是列表或者元组或者集合,里面的容器是元组或者列表(推荐)
lst = [("a",1),["b",2]]
tup = (("c",3),["d",4],)
setvar = {(1,2),(3,4),("a1",3),("b2",4)}
res = dict(lst) # {'a': 1, 'b': 2}
res = dict(tup) # {'c': 3, 'd': 4}
print(res)2.如果里面是集合,语法上允许,但是有局限性(不推荐)
lst = [{"a",1},{"b",2}] # 因为集合无序,不符合定义的本意,不推荐使用
print(dict(lst))3.如果使用字符串,语法上允许,但是有局限性(不推荐)
lst = [("a",1),"a2"] # 字符串长度只能2个
lst = [("a",1),"a123"] error
print(dict(lst))

容器类型总结

字符串（str）

字符串类型有索引，有序，可获取，不可修改，不可hash

列表（list）

列表类型有索引，有序，可获取，可修改，不可hash

元组（tupe）

元组类型有索引，有序，可获取，不可修改，不可hash

字典（dict）

字典类型有键值对（通过键获取），看似有序实则无序，可获取，可修改，可hash

集合（set）

集合类型无索引，无序，不可获取，可修改，可hash

垃圾回收机制

概念

一. Python内部使用引用计数机制, 来保持追踪内存中的对象,所有对象都有引用计数. 一个对象分配一个新名称,
然后将其放入到一个容器中(如列表, 元祖, 字典), 这样这个计数就增加. 当我们使用delect删除语句对对象别名进行删除或者,
引用超过了这个作用域,或者被重新复制的时候,引用的计数会减少.对于不可变数据(数字,字符串)解释器会在程序的不同部分共享内存,
以便节约内存.sys.getrefcount( )函数可以获得对象的当前引用计数二. 这个垃圾回收机制呢, 就是当一个对象的引用计数归零时,他就会被垃圾回收机制处理掉 ,当两个对象相互引用的时候,
del语句可以减少 引用次数并销毁引用底层对象的名称, 由于每个对象都包含一个对其他对象的引用, 因此引用计数不会归零,
对象也不会销毁,为解决这一问题，解释器会定期执行一个循环检测器，搜索不可访问对象的循环并删除它们。三.内存池机制Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。1，Pymalloc机制。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。2，Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的malloc。3，对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。
也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。

变量的缓存机制

Number类型

1.对于整型而言，-5~正无穷范围内的相同值id一致

2.对于浮点数而言，非负数范围内的相同值id一致

3.布尔值而言,值相同情况下，id一致

4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)

容器类型

1.字符串 和 空元组 相同的情况下，地址相同

2.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]

python的基础数据类型相关推荐

1. python之基础数据类型初识，int，bool，str 转化，for循环

   基础数据类型 一.总览 1.小知识 2. 基础数据类型总览 二.int.bool 1.int 2.bool 三.字符串str 1.索引切片步长 2.字符串中常见方法 1.capitalize() 2. ...

2. Python中基础数据类型（List、Tuple、Dict）的概念和用法

   在Python中会有很多的数据类型,今天小千就来介绍其中的三种,列表,元组,字典和他们的概念与用法,看完你就都明白了. 一.列表 首先List是有[]包括的,每个元素用(逗号)隔开,List中可以嵌套 ...

3. Python-07：Python语法基础-数据类型

   1.基本数据类型 2.列表 在Python中没有数组!!!和数组类似的就是列表和元组了 列表就是存储一连串元素的 容器.用[]来表示,是 有序排列的 3.元组 元组里面的元素也是能进行索引计算的 元组 ...

4. python的历史 常量 注释 基础数据类型等基本操作 和if 判断语句

   # Day1内容大纲 cpu 内存 硬盘 操作系统 cpu:计算机运算和计算中心,相当于人类大脑. 内存:暂时存储数据,临时加载数据应用程序,速度快,断电即消失 硬盘:磁盘,长期存储数据. 操作系统: ...

5. Python基础数据类型---列表、元组、字典、集合、编码进价、数据类型转换

   文章目录 一.列表(List) 二.元组(tuple) 三.字典(dict) 四.集合(set) 五.数据类型间的转换 六.基础数据类型的总结 七.编码 八.练习题 一.列表(List) 列表是pyt ...

6. Python变量，常量，基础数据类型，input用户交互

   Python变量 我们先看这样几个表达式 print ('hello world') print(1+2+3+4+5) print((1+2+3+4+5)*3/2) print((((1+2+3+4+ ...

7. 第2章 Python编程基础知识 第2.1节 简单的Python数据类型、变量赋值及输入输出

   第三节 简单的Python数据类型.变量赋值及输入输出 Python是一门解释性语言,它的执行依赖于Python提供的执行环境,前面一章介绍了Python环境安装.WINDOWS系列Python编辑和 ...

8. python中列表数据类型_python基础数据类型一(列表)

   列表 列表是python的基础数据类型之一 ,其他编程语言也有类似的数据类型. 比如JS中的数 组, java中的数组等等. 它是以[ ]括起来, 每个元素用' , '隔开而且可以存放各种数据类型: ...

9. python输入123输出321的编程_第2章 Python编程基础知识 第2.1节 简单的Python数据类型、变量赋值及输入输出...

   第三节 简单的Python数据类型.变量赋值及输入输出 Python是一门解释性语言,它的执行依赖于Python提供的执行环境,前面一章介绍了Python环境安装.WINDOWS系列Python编辑和 ...

最新文章

1. 第二十到第二十一天：让你和页面对话-IFE
2. HashMap,LinkedHashMap,TreeMap的有序性
3. Java基于Socket文件传输示例
4. asp.net 无法获取客户端请求的真实协议https
5. android+java.lang.VerifyError
6. 小程序 — 保存图片到手机相册①
7. .Net 数据缓存浅析
8. 蒋江伟：代码是我们最重要的资产！
9. Keil(MDK) 5 软件安装教程
10. Labview调用python
11. 电脑桌面计算机英语,IT计算机英语词汇
12. vue+barcode实现扫一扫功能
13. Java工程师 数据结构与算法 数组面试题（Day40）
14. python交易是什么意思_py交易什么梗?起源及流行原因
15. strace命令总结
16. 全球时区查询 API数据接口
17. 前端学习笔记 - 用CSS实现一个背景色为红色，半径为200px的圆，并设置不停的上下移动动画
18. Apollo坐标系转换
19. 逻辑函数的简化之图解法（卡诺图法）
20. mac与windows下各自的md5、sha1、sha256命令行校验工具

热门文章

1. js中的遍历和jquery中的遍历
2. Python爬取天气数据及可视化分析
3. 服务器Linux硬盘分区,Linux磁盘分区实现原理及方法解析
4. 运行时，so库找不到的原因
5. 2021年全球烤面包机收入大约1363.7百万美元，预计2028年达到1536.8百万美元
6. [开发技巧]·TopN指标计算方法
7. 订单超时未支付的解决方案
8. C语言怎么把单词拆成字母,如何用C语言切出汉语单词和英语单词混合字符串
9. ESP8266环境搭建-ESP8266_RTOS_SDK(超详细）
10. 1024: 大小写转换（C语言）