03-Python数据类型

None类型

Python3中没有NULL，取而代之的是空类型None、空列表、空字典等。
None是一个特殊的Python对象，表示无。
None的类型是NoneType。

如果只想声明变量，而不想赋值，可以这么做：

a=None     #声明一个变量

通过type()函数可以查看变量的类型:

a=None
print(type(a))  #输出<class 'NoneType'>

---

数字类型

Python3中有以下数字类型：

• int #整数
• float #浮点数
• bool #布尔类型
• complex #复数

小贴士：

Python2中还有long类型。
到了Python3中，整数都变成了int。

int整数

示例：

a=1     #定义一个int型变量

强制转换：

print(float(2))     #将int转换成float (结果为2.0)
print(chr(65))      #将一个整数转换为一个字符 (结果为A)
print(ord('a'))     #将一个字符转换为它的整数值 (结果为97)
print(hex(15))      #将一个整数转换为一个十六进制字符串 (结果为0xf)
print(oct(10))      #将一个整数转换为一个八进制字符串 (结果为0o12)

float浮点数

示例：

a=2.4       #定义一个float变量

强制转换：

int(2.4)   #将浮点数强制转换成int,会将小数部分剔除 (结果为2)

bool布尔类型

bool类型只有两个值：True和False。

示例：

b=True
b= 1>3 and 4>0  #逻辑语句(结果为False)

在Python中，0、None、空列表、空字典等为False，其他都为真。

但None和空列表等比较特殊：

a=None and True     #结果为None
b=None and False    #结果为None
c=[] and True       #结果为[]
d=[] and False      #结果为[]

a=None or True     #结果为True
b=None or False    #结果为False
c=[] or True       #结果为True
d=[] or False      #结果为False

print(not [])      #结果为True
print(not None)    #结果为True

complex

complex由实数和虚数组合构成，分别表示为：x+yj。
其中，x和y都是浮点数。

示例：

a=1+2.3j        #定义一个复数
a=complex(2,3)  #定义一个复数

complex可以进行算术运算：

a=1+2j
b=2+3j
print(a+b)

complex的属性与函数：

a=1+2.3j
print(a.real)   #返回实部 (结果为1.0)
print(a.imag)   #返回虚部 (结果为2.3)
print(a.conjugate())    #返回共轭复数 (结果为1-2.3j)

---

List列表

什么是列表

• List类似C语言中的数组，但List能提供更为强大的功能，如增删改查、排序、切片等
• 列表中的元素可以是不同的数据类型。
• 下标从0开始

示例：

a=[11,22,33,44]     #定义一个列表
a=['张三',18,"男"]  #列表中的元素可以不同数据类型

访问元素：

a=[11,22,33,44]
print(a[0])     #访问下标为0的元素，输出11

List嵌套

List中可以是不同数据类型：

a=[1,2,'abc']

既然说列表中的元素可以是不同数据类型，那么元素也可以是List:

a=[11,22,[1,2,3,4],44]
print(a[2])     #输出[1, 2, 3, 4]
print( a[2][1] )#输出2

解释：

• a[2]得到的元素也是一个列表[1,2,3,4]
• a[2][1]表示得到列表中的列表中的元素2，将a[2]看作一个整体
• a[2][1]形式与C/C++等语言中的二位数组类似。

增-往列表中添加数据

• 追加、插入

a=[11,22,33,44]
a.append('abc')     #在最后追加元素'abc'
a.insert(2,'qwe')   #在下标2处添加元素'qwe',原先2以后的元素依次后移
print(a)            #输出[11, 22, 'qwe', 33, 44, 'abc']

• 合并列表

a=[11,22,33,44]
b=['aa','bb']
c = a+b       #列表合并后赋值给c (a和b本身无变化)
print(c)      #输出[11, 22, 33, 44, 'aa', 'bb']

a=[11,22,33,44]
b=['aa','bb']
a.extend(b) #将列表b插入到a的后面
print(a)    #输出[11, 22, 33, 44, 'aa', 'bb']

删-删除列表中的元素

• remove()

a=['aaa','bbb','ccc','bbb']
a.remove('bbb')     #删除第一个'bbb',a变成['aaa', 'ccc', 'bbb']
a.remove(a[2])      #删除下标为2的元素

通过a.remove('bbb')可以知道remove函数是通过元素值来删除的。

a.remove(a[2])适用于元素不重复的列表，不然可能删除的不是下标为2的元素，而是在这之前的、与a[2]内容相同的元素。

• pop()

a=['aaa','bbb','ccc','bbb']
a.pop(2)    #删除下标为2的元素,返回删除的值
a.pop()     #删除最后的元素,返回删除的值

• del

a=['aaa','bbb','ccc','bbb']
del a[2]    #删除下标为2的元素
del a       #删除此列表

• clear()清空列表

a.clear()   #清空列表

• 进阶：通过append()和pop()实现栈的功能

append()追加，用于入栈
pop()弹出，用于出栈

a=[]
a.append(1)     #入栈 (a=[1])
a.append(2)     #入栈 (a=[1,2])
i=a.pop()       #出栈 (a=[1],i=2)

查-查询列表中的元素

• 通过下标可以直接查询

a=['aaa','bbb','ccc','bbb']
print(a[1])     #输出bbb

• 通过运算符 in 可以查询是否存在某元素

a=['aaa','bbb','ccc','bbb']
if "ccc" in a:
    print("a中存在元素'ccc'")

解释：

“ccc” in a 将返回bool值

若a中存在元素"ccc"，则返回True，否则返回False

与运算符in对应的是not in

切片

通过切片可以截取列表中的片段

切片语法:

a = ['aaa','bbb','ccc','ddd']
b = a[0:2]    #截取下标0~1的元素，产生新列表赋值给b
b = a[1:]     #截取下标1到最后一个元素

结果：

['aaa', 'bbb']
['bbb', 'ccc', 'ddd']

解释：

b = a[0:2]中的0表示切片起始下标(包括下标0)

b = a[0:2]中的2表示切片结束下标(不包括下标2)

如果省略结束下标，即一直切片到最后一个元素

切片-步长

示例：

a = ['aaa','bbb','ccc','ddd','eee','fff','ggg']
b = a[0:5:2]    #结果为['aaa', 'ccc', 'eee']

解释：

b = a[0:5:2]中的2表示步长
步长为2时，切片就会间隔2个元素进行截取元素。
上例将bbb、ddd、fff丢弃，切片到fff结束

• 当步长为负数时，表示从右往左切片。

a = ['aaa','bbb','ccc','ddd']
b = a[-1:-3:-1]     #结果为['ddd', 'ccc']

解释：

最后的-1表示步长
当步长为负数时，表示从右往左切片
-1代表倒数第一个字符
-3代表倒数第三个字符
默认步长为1，表示从左到右无间隔切片

改-修改列表中的元素

通过下标修改：

a = ['aaa','bbb','ccc','ddd']
a[1]='111'     #将'bbb'修改为'111'
print(a)       #结果为['aaa', '111', 'ccc', 'ddd']

通过切片修改：

a = ['aaa','bbb','ccc','ddd']
a[1:3]=['111','222']    #将下标1~2修改为'111','222'
print(a)       #结果为['aaa', '111', '222', 'ddd']

列表-排序

a = ['aaa','bbb','ccc','ddd']
a.sort()                #从小到大排序(会改变自身)
a.sort(reverse=True)    #从大到小排序
b=sorted(a)             #将a排序后返回给b，a不发生变化
a.reverse()             #反转

列表-内置函数

a = ['aaa','bbb','aaa','bbb']
print( a.index('bbb') )   #查找元素bbb的下标(若有多个，只返回第一个)(此结果为1)
print( a.count('bbb') )   #返回元素222的数量 (结果为2)
print( len(a) )           #返回列表元素个数 (结果为4)

遍历列表

在Python中，只要为序列，就可以被遍历，List自然不例外

示例：

a = ['aa','bb','cc','dd']
for i in a:
    print(i)

结果：

aa
bb
cc
dd

列表生成式

利用列表生成式，可按照表达式生成列表

示例：

a=[x*x for x in range(100)]print(a)

结果:

[0, 1, 4, 9, 16, …… , 9604, 9801]

解释：

• x的值依次为0~99
• x*x为表达式，所以列表中的值依次为0²,1²,2²,3²,……,99²

for+if

a=[x*x for x in range(100) if x%2==0]
print(a)

结果：

[0, 4, 16, 36, …… , 9216, 9604]

解释：

• 由于if语句的过滤，x的值依次为0，2，4，6，…… ，96，98
• x*x为表达式，所以列表中的值依次为0²,2²,4²,6²,……,98²
• 除此之外，还有for+for等语句

for+函数

def func1(x):
    return x*x
a=[func1(x) for x in range(100)]
print(a)

---

元组Tuple

元组和List类似，拥有很多一样的属性和方法。
唯一的区别是：元组内的元素不可被修改。

示例：

a = ('aaa','bbb','ccc','ddd')
print(a[2])     #输出ccc

---

字典Dictionary

什么是字典

字典有以下特征：

• Python中唯一的映射类型
• 由键和值构成
• 通过键存取元素，所以键唯一
• 无序存储，会被哈希
• 键必须是不可变类型
  • 可变类型 ：列表，字典等
  • 不可变类型：整型，浮点型，布尔型，元组等

举例：

dic1={'name':'flight','age':20,'sex':'male'}        #定义一个字典

一个键对应一个值：

增加和修改元素

在字典中，键相当于List中的下标，通过键就可以对值进行存取

例如：

dic1['age']=20      #通过下标修改或增加键值对

• 当字典中不存在此键时，就添加此键值对。

示例：

dic1={'name':'张三','age':18,'sex':'男'}
print( dic1['name'] )       #输出：张三
dic1['age']=20              #将age修改为20
dic1['favorable']='计算机'  #添加键值对'favorable':'计算机'

查询元素

在字典中，键相当于List中的下标，通过键就可以对值进行存取

同样的道理，通过键来取出想要的键值对。

示例：

dic1={'name':'张三','age':18,'sex':'男'}
dic1['name']       #取值(不存在则报错)
dic1.get('name')   #取值(不存在不报错)

通过in、not in查询：

dic1={'name':'张三','age':18,'sex':'男'}
if 'name' in dic1:      #dic1中存在此键则为True
    print("dic1中有'name'键")

删除元素

dic1={'name':'张三','age':18,'sex':'男'}

del dic1['name']        #删除键为'name'的键值对
del dic1                #删除整个字典
dic1.clear()            #清空字典
myName=dic1.pop('name') #删除键为'name'的键值对，并返回'name'的值
kv=dic1.popitem()       #删除最后添加到字典中的键值对,并返回此键值对

排序

• 字典的键是无序的。
• sorted函数可以得到一个根据键排序后的列表，再根据此列表进一步得到相应的值。

示例：

dic1={'name':'张三','age':18,'sex':'男'}
list1 = sorted(dic1)    #得到['age', 'name', 'sex']
for i in list1:
    print(dic1[i])

结果：

18
张三
男

字典中的内置函数

• setdefault()函数

dic1={'name':'张三','age':20,'sex':'男'}
a=dic1.setdefault('age',18)     #如果存在此键，不作任何变动；如果不存在，增加此键值对
			        #还返回age此时的值

• keys()、values()、items()

dic1={'name':'张三','age':20,'sex':'男'}
list(dic1.keys())     #得到所有的键,list做强制转换
list(dic1.values())   #得到所有的值,list做强制转换
list(dic1.items())    #得到所有的键值对,list做强制转换

• update()

dic1={'name':'张三','age':20}
dic_temp={'name':'李四','birthday':'1998-01-01'}
dic1.update(dic_temp)  #将dic_temp加入到dic中，键重复则覆盖
print(dic1)     #结果为{'name': '李四', 'age': 20, 'birthday': '1998-01-01'}

• fromkeys()

dic1=dict.fromkeys(['host1','host2','host3'],'test')   #创建并初始化字典
print(dic1)

结果：

{'host1': 'test', 'host2': 'test', 'host3': 'test'}

解释：

fromkeys()函数用于创建并初始化字典
参数1：key
参数2：value
每一个键对应的值都为’test’

---

集合-Set

什么是集合

• 集合（set）是一个无序的、不重复元素序列。
• 集合中的元素可以是不同数据类型。
• 可以使用大括号 { } 或者 set() 函数创建集合
• 注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建一个集合：

s1=set()        #创建一个空集合
s2={1,2,3,1,2}  #会被去掉重复项，变成{1, 2, 3}
s=set('Hello') #s={'H','e','l','o'}

强制转换：

list1=[1,2,3,1,2]s1=set(list1)       #将List转换成set，去除重复项list1=list(s1)      #将Set转换成List，变成[1, 2, 3]

List和Set可以互相转换

增

s={1,2,3}

s.add('uu')        #增加一个元素
s.update('pos')    #增加'p', 'o', 's'三个元素
s.update('a','b')  #增加'a','b'两个元素(update函数可以传入多个参数)

删

s={1,2,3}

s.remove('o')  #移除元素'o'
chr=s.pop()    #随机弹出一个值，并返回这个值
s.clear()      #清空集合

查

s={1,2,3}

if 1 in s:     #查询s中是否含有元素 1
    print("s中含有元素1")

集合运算

a < b     #判断a是否属于b，相当于a.issubset(b)
a > b    #判断b是否属于a，相当于a.issuperset(b)
a == b    #判断a和b是否相等

还有>=、<=负号

a & b   #交集，相当于a.intersection(b)
a | b  #并集，相当于a.union(b)
a - b  #差集，相当于a.difference(b)
a ^ b  #对称差集(去除交集后的并集),相当于a.symmetric_difference(b)

示例:

a={1,2}
b={1,2,3}
print(a<b) #判断a是否属于b

---

字符串-String

关于String

在Python中，单引号和双引号的作用是一样的

s1='eagle'
s2="eagle"

多行字符串：

msg='''
    hello1
    hello2
    hello3
'''

字符串中带有单引号和双引号：

print("it's mother's apple")    #输出单引号
print('"I love you"said Tom')   #输出双引号
print(''' aaa""bbb''ccc''')     #输出单双引号

字符串运算

• 切片：同样可以像List一样切片

s1='eagle'
s2=s1[1:3]      #s2='ag'
print(s2)

• 通过下标[]获取字符

s="hello"
print(s[1])     #输出e

• 乘法与加法

"123qwe"*2          #结果为'123qwe123qwe'
c='123'+'abc'     #效率比较低，可以使用join方法(结果为'123abc')

• in和not in运算符

if 'el' in 'hello':    #判断'el'是否存在于'hello'中
    print('''  "hello"中含有字串'el'  ''')

转义符

示例：

s="hello\nworld"    #\n被转义成换行
print(s)

结果：

hello
world

• 取消转义

s=r"hello\nworld"    #字符串前加 r，表示取消转义
print(s)       #结果为hello\nworld

转义符：

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\’	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy 代表的字符，例如：\o12 代表换行，其中 o 是字母，不是数字 0。
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

强制转换

• Python中，万物皆可转化为字符串。

示例：

str([1,2,3])
str({"name":"张三","age":18})

字符串中的内置函数

s='+'.join(['a','b'])   #使用'+'连接'a'和'b' (结果为'a+b')
s=''.join(['a','b'])    #连接列表中的元素 (结果为'ab')
s='+'.join('abc')       #使用'+'夹在'abc'各字母的中间 (结果为'a+b+c')
s='hello my home'.split(' ')   #使用' '分割字符串，返回一个列表 (结果为['hello', 'my', 'home'])
c='hello'.count('l')       #计算字母的个数 (结果为2)
s='hello'.capitalize()     #将首字母大写 (结果为'Hello')
s='hello'.center(10,'-')   #字符串居中，'-'填充，总占用10个位置 (结果为'--hello---')
b='hello'.startswith('he') #查看字符串是否以he开头，返回布尔值 (结果为True)
b='hello'.endswith('lo')   #查看字符串是否以lo结尾，返回布尔值 (结果为True)
c='hello'.find('ll')       #查找'll'的下标 (结果为2)
c='hello'.index('ll')      #查找'll'的下标，如果不存在则报错 (结果为2)
s='hello {name}'.format(name='flight') #将{name}置换成'flight'返回 (结果为hello flight)
s='hello {name}'.format_map({'name':'flight'}) #参数为字典 (结果为hello flight)
b='123'.isdigit()          #查看字符串是否为整型数字,返回bool值 (结果为True)
b='2flight'.isidentifier() #查看字符串是否符合命名规则 (结果为False)
b='aBc'.islower()      #查看字符串是否全小写 (结果为False)
b='aBc'.isupper()      #查看字符串是否全大写 (结果为False)
b='   \t'.isspace()    #查看字符串是否全为空白字符 (结果为True)
s='My'.lower() #所有大写字母变小写 (结果为'my')
s='My'.upper() #所有小写字母百年大写 (结果为'MY')
s='My'.swapcase()      #大写变小写，小写变大写 (结果为'mY')
b='My Home'.istitle()  #查看字符串是否为标题格式(所有单词首字母大写)(结果为True)
s='Hello eagle'.title()    #将字符串变成title格式 (结果为'Hello Eagle')
s=' hello \n'.strip()  #将字符串开头和结尾的空格、换行符和制表符去除 (结果为'hello')
s='hello'.replace('he','123')  #将'he'替换成'123' (结果为'123llo')

---

bytes类型

• bytes是Python3中新增的数据类型，是以字节为单位存储的序列。
  bytes是一种特殊的字符串。
  String拥有的内置函数，一般bytes也拥有
  由于bytes使用字节存储，可作为字节流写入文件、发送网络报文等

a=b'123'            #这是bytes，而不是字符串
print(type(a))      #输出<class 'bytes'>

解释：

• 上例中，在字符串前加b用于标明，这是bytes，而不是str

str与bytes互相转换

s1="你好"
b=bytes(s1,"UTF-8")   #UTF-8编码的字符串 -> bytes
b=s1.encode("utf8")   #UTF-8编码的字符串 -> bytes
print(b)    #输出：b'\xe4\xbd\xa0\xe5\xa5\xbd'

s2=str(b,"UTF-8")     #bytes -> UTF-8编码的字符串
s2=b.decode("utf8")   #bytes -> UTF-8编码的字符串
print(s2)   #输出：你好

解释：

从 \xe4\xbd\xa0\xe5\xa5\xbd 可以看出，一个中文占3个字节

---

深浅拷贝

浅拷贝

a=[[1,2],3,4]b=a.copy() #浅拷贝，只拷贝第一层

解释：

• 当b[0]中的元素改变之后，a的值也会变化。如b[0][1]=100。
  原因是a中第0个元素使用地址保存，同样的地址被赋值给b。a[0]和b[0]指向同一块内存。

深拷贝

import copy         #引入模块
a=[[1,2],3,4]
b=copy.deepcopy(a)  #深拷贝

下例情况不是拷贝

a=[[1,2],3,4]
b=a

解释：

• a直接赋值给b，那b和a就指向同一块内存，不存在拷贝列表中元素这一说。