三、Python基本数据类型

一、几个概念

1.1、表达式
表达式室友数字、算符、数字分组符号（括号）、自由变量和约束变量等以求得数值的有意义排列方法所得的组合。

1.2、语句
一个语法上自成体系的单位，它由一个词或句法上有关连的一组词构成的。

1.3、程序
程序就是由一条一条的语句和一条一条的表达式构成的。

1.4、函数
函数就是一个语句专门用来完成特定的功能。
形容：XXX()
函数的分类：内置函数、自定义函数

内置函数：

二、标识符

Python语言的组成：
（1）关键字
（2）标识符
（3）注释
（4）变量和数值
（5）运算符
（6）语句
（7）函数
（8）序列

2.1、关键字

import keyword
print(keyword.kwlist)

2.2、标识符
开发人员在程序中自定义的一些符合的命名规则的名称，例如，变量名、类名、函数名…

1. 标识符的组成：由26个英文字母大小写、数字和符号组成
2. 标识符的规则：
   （1）标识符可以包含字母、数字、_，但不能使用数字做开头；
   （2）Python中不能使用关键字和保留字作为标识符；
3. 命名方式（原则：见名识意）
   （1）小驼峰myName aDog第一个单词以小写字母开始，第二个单词首字母大写；
   （2）大驼峰FirstName LastName每一个单词的首字母都采用大写；
   （2）下划线命名法：用下划线来链接两个有含义的单词；

三、数字类型

3.1、数字类型是不可变类型
所谓的不可变类型，指的是类型的值一旦有不同了，那么它就是一个全新的对象。数字1和2分别代表两个不同的对象，
对变量重新赋值一个数字类型，会新建一个数字对象。

3.2、Python变量和数据类型的关系
变量只是对某个对象的引用或者说代号、名字、调用等等，变量本身没有数据类型的概念。
只有1，[1,2]，“hello”这一类对象才具有数据类型的概念。

python支持三种不同的数字类型，整数、浮点数和复数。

3.3、整数
整数通常被称为整型，数值为正或者负，不带小数点。

表示数字的时候，有时我们还会用八进制或十六进制来表示：
十六进制用0x前缀和0-9，a-f表示；
八进制用0o前缀和0-7表示；
Python的整数长度为32位，并且通常是连续分配内存空间的。

当整数数据比较大的时候，可以使用下划线进行分隔。

a=999_56544_4546
print(a)

3.4、浮点数和复数
浮点数也就是小数。但是对于很大或是很小的浮点数，一般用科学计数法表示，把10用e代替。

浮点数在十进制转化成二进制时，会出现精度问题，这在各种编程语言中都会出现这种问题。

在计算过程中，只要有浮点数，计算结果就是浮点数。

3.5、复数
复数由实数部分和虚数部分构成，可以用a+bj或complex（a,b）表示，复数的实部a和虚部b都是浮点数。

四、布尔类型和空值

4.1、布尔类型
对于0和1、正和反，都是传统意义上的布尔类型，
但是在python语言中，布尔类型只有两个值，True和Flase（分别等同于1和0，布尔值实际上也属于整型）。

4.2、空值
空值不是布尔类型，空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是整数类型，而None是一个特殊的值。
None不是布尔类型，而是NoneType

五、字符串

5.1、字符串的定义
字符串就是有数字、字母、下划线组成的一串字符。

用一对单引号或者是双引号包裹的内容就是字符串,单引号或者是双引号必须成对出现，相同引号之间不能嵌套。

字符串的表现形式：str

字符串的存储方式：
整型在内存中占一个字节，字符串不管中间有多少内容都要单独存储。“abcd”->>“a”,“b”,“c”,“d”

5.2、转义字符()
\‘ 表示’
\’ 表示‘
\t 表示制表符，tab键
\n 表示换行符号，Enter键
\ 表示反斜杠，\键

5.3、原始字符串
r+字符串 表示的原始字符串，表示里面的内容就是一个字符串，例如：

a=r"D:\Program Files"
print(a)

5.4、长字符串
一般长字符串用三重引号表达，三重引号表示一个完整的字符串，包含字符串的原始样式（格式）：

a="""
    关关雎洲，
    在河之洲；
    窈窕淑女，
    君子好逑。
"""
print(a)

5.5、格式化字符串
字符串拼接：
（1）加号（+）方式拼接：print（“美女，”+‘你好’）
（2）可以指定占位符：%s占位字符，%d占位整数，%f占位浮点数；

a='i love %s \n' #模板复制
a=a%"wang"

b='i love {0}\n'.format("wang")

s='s1=%s,s2=%s\n'%('Hello','world') #多个参数时，可以用元组表示。

t='t1={0},t2={1}\n'#模板复制
t=t.format('Hello','world')

n1 = '钢铁侠'
n2 = '葫芦娃'
n = f'Hello {n1},{n2} \n' #n1,n2在必须提前定义,表示的是占位方式，当{}有变量，且变量有值时使用

print(a,b,s,t,n)

（3）format

s='i love {0}' #采用索引值得方式，只要将占位的顺序放在{}就可以
a=s.format("python")
print(a)

name='女神'
print(name +'，你好') #拼串
print(name,'，你好')#多个参数
print('%s，你好'%name)#占位符
print(f'{name}','你好')

5.6、格式化字符串
（1）字符串的长度：len()
（2）判断一个字符串是否在另一个字符串中：in
（3）求最大值和最小值：max()和min()
（4）ASCII码查看：ord(‘y’)返回的是ASCII里面对应字符的十进制序号
（5）字符串分隔：split()
（6）拼接字符串：jion()
（7）去空格：strip()，lstrip(),rstrip()
（8）字符串的大小写：lower（）全部小写,upper（）全部小写
（9）capitalize()首字母大写
（10）isupper(),islower():判断是否大小写，返回值：TRUE或False
（11）字符串和整数的转换：int，str
（12）字符串的输入和输出：input，print
（13）字符串下标：name=“abcdef”,如何取出c值。
（14）字符串切片：name[初始位置:终止位置:步长],eg:name[0:2]
（15）字符串中常见的操作：
find:查找第一个匹配上的位置，若无匹配，返回-1；rfind:从右侧开始匹配；
index：跟find一样，区别：若无匹配，直接报错；rindex:从右侧开始匹配；
replace：替换（原先的字符，新字符串，替换前几个出现的），替换完成后只返回，原来的字符串不改变；
startswith，endswith：判断是否以某个字符开始或结束，主要用于判断姓氏和后缀
title：按标题格式将每个单词的首字母大写。
isalpha：判断字符串是否是纯字母；
isdigit：判断是否是纯数字；
isalnum：判断是否是字母和数字。

六、列表

列表是Python中最基本也是最常用的数据结构之一，列表中的每个元素都被分配一个数字作为索引，用来表示该元素在列表内所排在的位置，第一个元素索引是0。

Python的列表是一个有序可重复的元素集合，可嵌套、迭代、修改、分片、追加、删除，成员判断。

从数据结构角度看，Python的列表是一个可变长度的顺序存储结构，每一个位置存放的都是对象的指针。

列表存储数据性能很好，但是查询数据性能很差。

6.1、列表的操作方式
（1）创建方式：只要把逗号分隔的不同的数据项使用方括号括起来或用list()函数。

'''
创建列表的两种方式
1、[]
2、list()
ctrl+鼠标点击-->查看源码
iterable 可以用for循环，都是可迭代的
'''
l=[]
ll=list()
print(ll)

（2）列表元素的访问
列表从0开始为它的每一个元素顺序创建下标索引，知道总长度减一。要访问它的某个元素，以方括号加下标值得方式即可。注意要确保索引值下标不越界，一旦访问的索引超过范围，会抛出异常。

'''
查询元素：采用列表索引的方式，列表索引从0开始
PyCharm快捷键，Ctrl+W快速复制当前行
'''
lis=['a' , 'b', 'c']
value=lis[0]

（3）修改元素的值：直接对元素进行重新赋值。

lis=['a' , 'b', 'c']
value=lis[0]
list()
'''
修改元素的值:
不能赋值列表中不存在的索引
'''
lis[1]='e'
print(lis)

lis[3]='e'

（4）删除元素：
del语句->采用下标表示，用于一维；
remove()->删除元素值，不用下标，只能用于一维；
pop()->删除指定下标的元素,默认删除最后一个元素。

'''
列表删除
'''
lis=['a' , 'b', 'c']
#指定元素删除：
del lis[0]
print(lis)
#根据元素的值进行删除
lis.remove('e')
#根据索引进行删除  默认删除最后一个值 传值的话 按照索引进行弹出
value=lis.pop(2)

（5）列表的组合：

'''
（1）列表相加
（2）列表的乘法
（3）判断元素是否在列表内部
（4）迭代列表中的元素
'''
lis1=[1, 2, 3]
lis2=[4, 5, 6]
#（1）
#列表的拼接 不是对应位置相加==>相当于魔术方法
lis3=lis1+lis2
print(lis3)
#魔术方法，面向对象
print(lis1.__add__(lis2))

#（2）
#列表乘以一个数n==》跟相加一样，相当于加了n次；两个列表不能相乘
lis3=lis1*3
print(lis3)
#---->
print(lis1.__imul__(3))

#（3）判断元素是否在列表内部:i in lis1
print(1 in lis1)

（6）列表的内置方法
append(obj):在列表末尾添加新的元素；
count(obj):统计某个元素在列表中出现的次数；
extend(obj):在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）；
index(obj):从列表中找出某个值第一个匹配项的索引值；
insert(index,obj):将对象插入列表；
pop(obj=list[-1]):移除列表中的一个元素（默认最后一个元素），并且返回该元素的值;
remove(obj):移除列表中某个值得第一个匹配项；
reverse()：反向列表中的元素；
sort([func]):对原列表进行排序；
copy():复制列表，浅拷贝；【注意：浅拷贝是拷贝的值，深拷贝拷贝的是内存地址id】
clear():清空列表，等于del list[:]

七、元组

元组也是序列结构，但是是一种不可变序列。

什么时候用列表？什么时候用元组？
一般当我们希望这个数据不变的时候我们就用元组，其余情况都用列表。

7.1、元组的操作方式
（1）元组与列表操作方式相同，但不允许增删改元素，可以删除整个元组。
（2）列表与元组的转换：list,tuple

'''
1、创建元组
用()创建元组
'''
my_tuple=() #创建一个空元组

my_tuple=(1,2,3,4,5,6) #创建非空元组

my_tuple=10,20,30,40 #创建非空元组

print(my_tuple,type(my_tuple))#(10, 20, 30, 40) <class 'tuple'>
'''
2、解包
解包指的就是将元组当中的每一个元素都赋值给一个变量中。
元组、列表都可以解包，但是字典不能解包。

（1）在对一个元组进行解包时，变量的数量要和元组中元素保持一致；
（2）当变量和元组当中的数量不一致时，我们可以在变量前面添加一个*，
这样变量将会获取元组中剩余的元素，剩余元素返回的是列表数据结构。

'''
my_tuple=10,20,30,40
a,b,c,d=my_tuple #元组的解包

a=6
b=8

b,a=a,b #这个也叫解包
print('a=',a,'b=',b) #a= 8 b= 6

#（2）当变量和元组当中的数量不一致时，我们可以在变量前面添加一个*，
#这样变量将会获取元组中剩余的元素，剩余元素返回的是列表数据结构。
my_tuple=10,20,30,40
a,b,*c=my_tuple
print(a,b,c) #10 20 [30, 40]

a,*b,c=my_tuple
print(a,b,c) #10 [20, 30] 40

a=[10,20]
b,c=a
print(b,c)

八、字典

python的字典数据类型是基于hash散列算法实现的，采用键值对（key:value）的形式，根据key的值计算value的地址，具有非常快的查取和插入速度，但是它是无序的，包含元素个数不限，值得类型也可以是其他任何数据类型。

字典就像书中目录索引内容一样。
字典是一种新的数据结构，称之为映射（mapping），字典的作用就是用来存储对象的容器。

列表存储数据性能很好，但是查询数据性能很差。

字典中每一个元素都有唯一的一个名字，通过这个名字可以快速查找到指定的元素；
唯一的名字称之为键（key），通过键key可以查找到值（value）,所以字典，也称之为键值对（key-value）；
每个字典可以有多个键值对，每一个键值对我们称之为一项（item）。

字典的key必须是不可变的对象，例如，整数、字符串、bytes和元组，但使用最多的还是字符串，字典的键是不能重复的，如果出现重复，后面的会替换前面的；
字典的值可以是任意对象。

列表、字典、集合等就不可以作为key。同时，同一个字典内的key必须是唯一的，但值则不必。

8.1、字典的操作方式
（1）字典的创建：{‘key1’:value1,‘key2’:value2,…}，dict(key1=value1,key2=value2,…)

d={
    'name':'葫芦娃',
    'age':20
}

d=dict(name='葫芦娃',age=20)
#dict()这个函数可以将一个包含有双值子序列转换成字典，用dict（）不需要对键加引号；
#双值序列，序列中只有2个值[3,4]、('name','hello')、'xy'
#子序列，如果序列当中的元素也是序列，那么我们就称之为这个元素的子序列[(1,2)]
d=dict([('name','葫芦娃'),('age',18)]) #双值子序列

字典的键是不能重复的，如果重复，后面的会替换前面的。

（2）访问字典元素：
字典是集合类型，不是序列类型，因此没有索引下标的概念，更没有切片的说法。
但是，与list类似，字典采用把相应的键放入方括号内获取对应值的方式取值。

d={
    'name':'葫芦娃',
    'age':20
}

# d=dict(name='葫芦娃',age=20)
# #dict()这个函数可以将一个包含有双值子序列转换成字典；
# #双值序列，序列中只有2个值[3,4]、('name','hello')、'xy'
# #子序列，如果序列当中的元素也是序列，那么我们就称之为这个元素的子序列[(1,2)]
# d=dict([('name','葫芦娃'),('age',18)])

#获取字典里面的值
#语法：d[key]
d['name']
print(d['name'])

d={
    'name':'葫芦娃',
    'age':20
}
#len()获取字典当中键值对的个数
#in检查字典当中是否包含指定的键
#not in检查字典当中是不包含指定的键
#


print(len(d),d['name'],'name' in d)

#获取字典里面的值
print(d['name']) #当字典中没有‘name’时，会发生报错
print(d.get('返回这个键的值'),d.get('name'))
#dict.get()根据键来获取字典当中的值,如果获取的键不存在，会返回None,
#dict.get()也可以指定一个默认值，作为第二个参数，这样当获取不到键的时候会返回默认值。
print(d.get('hello'，'返回这个键的值'))

（3）字典的增加和修改
增加就是往字典插入新的键值对，修改就是给原有的键赋予新的值。
由于一个key只能对应一个值，所以，多次对一个key赋值，后面的值会把前面的值覆盖掉。

d={
    'name':'葫芦娃',
    'age':20
}

print(len(d),d['name'],'name' in d,d.get('返回这个键的值'),d.get('name'))

d['name']='黑猫警长'
d['phone']=22222

print(d)

#d.setdefault(key[,default]) #可以用来向字典中添加key-value
#如果key已经存在在字典当中，则返回key的值，不会对字典做任何操作
#如果key不存在，则向字典当中添加这个key,并设置value
result=d.setdefault('name','黑猫警长')
re=d.setdefault('panda','熊猫')

print(result,re,d)

（4）删除字典元素、清空字典和删除字典
使用del关键字删除字典元素或者字典本身，使用字典的clear()方法清空字典。

#update()将其他字典当中的key-value添加到当前的字典当中
d1={'a':1,'b':2}
d2={'c':'f','e':'6'}
d1.update(d2)
print(d1)

#删除 del
del d1['a']
print(d1)

#d1.popitem()随机删除字典当中的一个键值对，一般情况下都会删除最后一个键值对
#删除之后他会将所删除的key-value作为一个返回值返回元组形式

print(d1,d1.popitem())

#pop(key[,default])
#根据key删除字典当中的键值对key-value
#返回的是删除的value值
#如果删除不存在的key，会抛出异常key error
#如果指定了默认值，删除不存在的key值的时候，就返回默认值
print(d1.pop('x','没有这个key'))
print(d1.pop('c'))

#clear 清空字典
d1.clear()
print(d1)

（5）字典的浅复制

#浅复制（浅拷贝）
#copy()#用于对字典进行一个浅复制，只会复制字典本身，即id更改；不会复制字典中的字典，即字典中的字典的id、type和value均一样。

d1={'a':1,'y':{'b':2,'c':3}}

d2=d1

d1['a']=10

print('d1=',d1,id(d1),'d2=',d2,id(d2))#d1和d2的值和地址都一样

d2=d1.copy()

d2['a']='问题'
d2['y']['b']='hell'

print('d1=',d1,id(d1),'\n','d2=',d2,id(d2))
#d1= {'a': 1, 'y': {'b': 'hell', 'c': 3}} 1719942916680
#d2= {'a': '问题', 'y': {'b': 'hell', 'c': 3}} 1719942917400

（6）字典中常用的方法
.get(key):返回指定键的值，如果值不在字典中，则返回default，不报错；
.items():以列表返回可遍历的所有（键，值）元组对；

d1={'a':1,'y':{'b':2,'c':3}}
print(d1.items())#返回值双值子序列dict_items([('a', 1), ('y', {'b': 2, 'c': 3})])

.keys():以列表返回字典所有的键；
.values():以列表返回字典所有的值;
.len():获取字典当中键值对的个数；
in:检查字典当中是否包含指定的键；
not in:检查字典当中是不包含指定的键；

'''
字典的遍历
'''

d1={'a':1,'y':{'b':2,'c':3}}

for k in d1.keys(): #key遍历
    print(k)

for v in d1.values():#value遍历
    print(v)

for k,v in d1.items():#key、value遍历
    print(k,v)

九、集合

set集合是一个无序不重复元素的集，基本功能包括关系测试和消除重复元素。集合使用大括号{}框定元素，并以逗号进行分隔。但是注意，如果要创建一个空集合，必须使用set()而不是{}，因为后者创建的是一个字典。

集合数据类型的核心在于自动去重。

集合的表现形式：set
集合和列表基本一致；
不同点：
（1）集合只能存储不可变对象；
（2）集合中存储的对象是无序的；
（3）集合不能出现重复元素。

9.1、集合数据的操作方式
（1）添加元素：通过add(key)方法可以添加元素到set,可重复添加，但不会有效果。
（2）集合更新：可以通过update()方法，将另一个对象更新到已有的集合中，这一过程同样会进行去重。
（3）删除元素：通过remove(key)方法删除指定元素；或者通过pop()方法删除一个元素。

注意：集合的pop()方法无法通过设置参数来删除指定的元素。

需要注意的是，集合不能取出某个元素，因为集合既不支持下标索引也不支持字典那样的通过键值对获取，但可以先把集合转化为列表后，取值。

'''
集合
1、集合只能存储不可变对象
2、集合中存储的对象是无序的
3、集合中不能出现重复的元素
'''
#一、集合的基础
#1、集合的创建
#创建集合，使用{}来创建集合
s={10,9,3,4}

print(s,type(s))

#set()函数来创建集合
#set()可以把序列和字典转换为集合
s=set('python')
s=set({'a':1,'b':2}) #将字典转换为集合时，只是将字典的键转换为了集合。

#2、集合的查询
#查询集合中的元素时，需要先把集合转化为列表的形式
s={'a','b',10,9,3,4}

print(list(s)[0])

#3、集合的使用
# in 和 not in 来检查集合中的元素，结果会返回一个bool值
#len()获取集合中元素的个数（长度）

print('a' in s,len(s))

#add()可以向集合中添加元素
s.add(6)
print(s)

#update()将一个集合中的元素添加到当前集合中
s2=set('python')
s.update(s2)
print(s)

#pop()随机删除集合中的一个元素,返回被删除的元素
result=s.pop()
print(result)

#remove()删除集合中指定的元素
s.remove('p')

#clear()清空集合
s.clear()

#二、集合运算
s1={1,2,3,4,5}
s2={9,8,7,6,5,4}
#1、交集运算
result=s1 & s2

#2、并集运算
result=s1 | s2

#3、差集运算
result=s1-s2

#4、亦或集
result=s1 ^ s2

print(result)

#5、<=检查一个集合是否是另一个集合的子集
#<检查一个集合是否是另一个集合的真子集
#>检查一个集合是否是另一个集合的真超集
a={1,2,3}
b={1,2,3,4,5,6}
result=a<=b  #返回布尔值，判断a是否是b的子集，或a=b

print(result)

十、变量、可变对象和==、is

当数据不确定的时候，需要对数据进行存储时，就定义一个对象来完成存储动作。

对象就是计算机内存中的一块区域，存储规定范围内的值，值时可以改变的，通俗的说变量就是给数据起个名字。

对象的变量名需要符合标识符的命名规则。

注意：两个对象相等（表示值得大小一样）和两个对象是同一个对象（表示同一个内存地址，通过id()方法查看）是两个概念;

变量的运算总结：
只要在运算过程中含有浮点数，那么它返回的就是一个浮点数类型。

'''
1、可变对象
评价一个电脑的性能，一个是CPU，一个是内存。

内存保存了三个内容：id,type和value。
体现方式：
例如:a=[1,2,3]
则变量为a，变量值为0x111

内存体现方式为：
id=0x111
type=class list
value=[1,2,3]

a[0]=10，这个改变是value的改变，修改的是对象中的value值。

a=[4,5,6]，这个的改变是id的改变，修改的是变量值，相对于在内存中有了一个新的对象a。
'''
a=[1,2,3]
print('修改前:',a,id(a)) #修改前: [1, 2, 3] 1729157943752

a[0]=10
#这个操作是通过变量修改对象里面的值，
#这种操作不会改变变量指向的对象。
print('修改后:',a,id(a)) #修改后: [10, 2, 3] 1729157943752

b=a
b[0]=20
print('a',a,id(a)) #a [20, 2, 3] 1729157943752
print('b',b,id(b)) #b [20, 2, 3] 1729157943752

a=[4,5,6] #为变量赋值
print('修改后:',a,id(a)) #修改后: [4, 5, 6] 1729159157192

'''
2、==和is
==、！=比较的是对象的值是否相等
is、is not比较的是对象的id是否相等
'''
a=[1,2,3]
b=[1,2,3]
print(a,b)#[1, 2, 3] [1, 2, 3]
print(id(a),id(b))#2208468291976 2208468293064
print(a is b)#False
print(a == b)#True