System.InvalidOperationException:“未在本地计算机上注册“Microsoft.ACE.OLEDB.12.0”提供程序

EasyExcel实现数据的导出

  返回  

python的基础数据类型

2021/7/21 15:47:32 浏览:

文章目录

  • 前言
    • 什么是数据类型?
  • 一、python的基础数据类型
    • 数字类型(Number)
      • 整型 (int)
      • 浮点型(float)
      • 复数型(complex)
      • 布尔类型(bool)
      • 数学函数
      • 三角函数
      • 数学常量
      • 小数据池
    • 字符串类型(str ''或"")
      • 概念
      • 字符串的用法
      • 转义字符
      • 元字符串
      • 格式化字符串
      • 字符串的相关操作
      • 字符串的相关函数
        • 字符串常用的三个方法(重要)
    • 列表类型(list[])
      • 概念
      • 列表的操作
      • 列表的相关函数(增删及其他函数)
      • 深浅拷贝
        • 概念
        • 浅拷贝
        • 深拷贝
        • 深浅拷贝的总结
    • 元组类型(tupe())
      • 概念
      • 元组的常用操作
      • 元组的运算符
      • 元组的相关方法
    • 字典类型(dict{})
      • 概念
      • 字典的相关方法
    • 集合类型(set{})
      • 概念
      • 集合的相关操作
      • 集合的相关函数
      • 冰冻集合
    • 强制类型转换和自动类型转换
      • Number类型强制转换(int、float、bool、complex)
        • 整型 int
        • 浮点型 float
        • 布尔型 bool
        • 复数型 complex
      • Number自动类型转换
      • 容器类型的强制转换(str、list、tuple、set、dict)
        • 字符串类型 str
        • 列表类型 list
        • 元组类型 tuple
        • 集合类型 set
        • 字典类型 dict
    • 容器类型总结
      • 字符串(str)
      • 列表(list)
      • 元组(tupe)
      • 字典(dict)
      • 集合(set)
    • 垃圾回收机制
      • 概念
    • 变量的缓存机制
      • Number类型
      • 容器类型


前言

什么是数据类型?

我们人类可以很容易的分清数字与字符的区别,但是计算机并不能呀,计算机虽然很强大,但从某种角度上看又很傻,除非你明确的告诉它,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.21

a = 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) 返回 10

ceil(x)	返回数字的上入整数,如math.ceil(4.1) 返回 5

cmp(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.718281828459045

fabs(x)	返回数字的绝对值,如math.fabs(-10) 返回10.0

floor(x)	返回数字的下舍整数,如math.floor(4.9)返回 4

log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0

log10(x)	返回以10为基数的x的对数,如math.log10(100)返回 2.0

max(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.0

radians(x)	将角度转换为弧度

数学常量

pi	数学常量 pi(圆周率,一般以π来表示)
e	数学常量 e,e即自然常数(自然常数)。

小数据池

id 	=> id是内存地址

is 	=> 比较两边的内存是否相等

== 	=> 比较两边的数值是否相等

=	=> 是赋值

小数据池的缓存机制

小数据池,也称为小整数缓存机制,或者称为驻留机制等等,

对于数字: -5~256是会被加到⼩小数据池中的. 每次使⽤用都是同⼀一个对象.

对于字符串串:

1.如果字符串串的长度是0或者1, 都会默认进行缓存

2.字符串长度大于1, 但是字符串中只包含字母, 数字, 下划线时才会缓存

3.用乘法的到的字符串乘数为1, 仅包含数字,字母,下划线时会被缓存. 如果
包含其他字符, 而长度<=1 也会被驻存,乘数大于1 . 仅包含数字, 字母, 下划
线这个时候会被缓存. 但字符串串长度不能大于20

4.指定驻留留. 我们可以通过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) # True
 print(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      -1
    
res = 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])) # 2731177036872

print(id(lst1[0])) # 1347321968
print(id(lst2[0])) # 1347321968

lst2[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)	结果为 True

for 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'))
# 输出:977260134378667761

print(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可以转化成int

bool可以转化成int

str(形如"123")可以转化成int

complex不可以转化成int

str(形如"abc123")不可以转化成int

浮点型 float

int可以转化成float

bool可以转化成float

str(形如"123")可以转化成float

布尔型 bool

bool类型为假的十种情况:

0,  0.0False0j'',   [],   {},   (),  set(),   None

None 是python的关键字,代表空的,什么也没有,一般用来做初始化操作

复数型 complex

int可以转化成complex

float可以转化成complex

bool可以转化成complex

str(形如"123")可以转化成complex

str(形如"abc123")不可以转化成complex

Number自动类型转换

精度从低向高进行转换 : bool -> int -> float -> complex

自动类型转换,默认从低精度向高精度进行转换(从低到高)

可以实现以下几种自动类型转换:

1.bool+int

2.bool+float

3.bool+complex

4.int+float

5.int+complex

6.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标识都不同 [空元组例外]

联系我们

如果您对我们的服务有兴趣,请及时和我们联系!

服务热线:18288888888
座机:18288888888
传真:
邮箱:888888@qq.com
地址:郑州市文化路红专路93号