Python数据类型

摘要：字符串进阶原始字符串表示方式及使用如何格式化字符串中文字符串的使用原始字符串表示方式及使用防止转义字符输入过多而使代码阅读性下降注意原始字符串不得以结尾。列表中可以包含任何数据类型，也可包含另一个列表。

1.python的数据类型：

字符串

整数

浮点数

类型转换

字符串编码

列表、元组与字典

2.应用：

序列及其通用操作

相关逻辑运算

1.Python中的字符串通常由单引号“"”、双引号“"”、三个单引号或三个双引号包围的一串字符组成

2.字符串还可以通过序号（序号从0开始）来取出其中某个字符，例如"abcde"[1]取得的值为"b"

3.当字符串内含有单引号时，如果用单引号字符串就会导致无法区分字符串内的单引号与字符串标志的单引号，就要使用转义字符串，如果用双引号字符串就可以在字符串中直接书写单引号即可。比如："abc"dd"ef"、"acc"d"12"。

4.三引号字符串可以由多行组成，单引号或双引号字符串则不行，当需要使用大段多行的字符串行就可以使用它。比如：

"""
　　This is a word.
　　hello world.
"""

5.常见的转义字符如下：

n　换行符；

t　制表符（Tab）；

r　回车（Enter）；

　“”字符；

"　单引号字符串中的单引号；

"　双引号字符串中的双引号。

比如以下字符串中都包含了转义字符：

"abc
abc"        #包含一个换行符的字符串
"abc"2"abc" #字符串中包含被单引号引起的2　

6.字符串的运算中“+”就是连接字符串；“*”就是单字符串的多次连接

注意两个函数：
split()函数返回以指定的字符将字符串分割成为列表形式并返回，但并不改变原字符串，它的原型如下：

split( [sep [,maxsplit]])

其参数含义如下：

sep　可选参数，指定分割的字符，默认为空格；
maxsplit　可选参数，分割次数。

join()函数将原字符串插入参数字符串中的每两个字符之间。如果参数字符串中只有一个字符，那么返回参数字符串。同样，join()并不改变原字符串，只是返回一个新的字符串。

原始字符串表示方式及使用

如何格式化字符串

中文字符串的使用

1.原始字符串表示方式及使用
防止转义字符输入过多而使代码阅读性下降

print(r"abc
abc")   
result:abc
abc

print("abc
abc")     
result:abc
       abc

注意:

原始字符串不得以“”结尾。见图3.5所示的第三行（第二个示例）及后面错误提示。

2.如何格式化字符串

print("%d+%d=%x" %(1,89,1+89))

3.中文字符串的使用
在网络上发送字符串时要求必须转换为字节串（bytes）形式，那么就要使用字符串的encode()方法，它返回的是字节串（bytes），其形式如下：

encode(encoding="utf-8", errors= "strict")

参数意义如下：

encoding默认编码方式为utf-8，也可以使用gbk、gb2312等方式编码；
errors编码错误的处理方式，默认为strict（报错），也可以是ignore、replace等形式。反之，如果从网络上接收的字节串（bytes）若为字符串，则要使用字节串（bytes）的decode()方法来进行解码，才能看到原来的字符串，其原型如下: decode(encoding="utf-8", errors="strict") 其参数含义与前面encode()函数相同，返回的是字符串类型数据。

word="我好中意你!"
socket_word=word.encode("gb2312","strict")
print(socket_word.decode("gb2312"))

解码时的encoding要与编码时的encoding要一致，否则不能还原或报错。

0o[0O]数字　表示八进制整数（例如：0O24、0O24）

0x[0X]数字　表示十六进制整数（例如：0x3F、0X3F）

0b[0B]数字　表示二进制整数（例如：Obl01、0B101）

“//”运算符就是取商而丢弃余数，比如14÷4=3……2，所以14//4=3；而“%”运算符的运算结果是余数而丢弃商，所以14%4=2;“/”运算符的运算结果为浮点数，即使是两个整数相除。

|、^、&、<<、>>运算符都是位运算符，要依据其二进制形式进行运算

运算符优先级从高到低排列如下：

**

*、/、%

+、-

|、^、&、<<、>>

没有把握的情况下可以运用括号。

浮点数可以参加的运算支持表3.2中除位运算之外的运算符

str（object="）　可以将整数和浮点数转换为字符串，默认建立空字符串；

int（x, base=10）　将数字字符串或数值转换为整数（base表示数制）；

float（x）　将字符串或数值转换为浮点数。

此外：

str()可以创建一个空字符串。

int()也可以建立一个默认值为0的整数。

float()可以建立一个默认值为0.0的浮点数。

进制之间的转换：

dec = int(input("输入数字："))
print("十进制数为：", dec)
print("转换为二进制为：", bin(dec))
print("转换为八进制为：", oct(dec))
print("转换为十六进制为：", hex(dec))

注意：

将字符串形式的数值转换为整数时，其中只能包含数字。

具体实现

十进制到二进制：

def dec2bin(num):
    l = []
    if num < 0:
        return "-" + dec2bin(abs(num))
    while True:
        num, remainder = divmod(num, 2)
        l.append(str(remainder))
        if num == 0:
            return "".join(l[::-1])

十进制到八进制：

def dec2oct(num):
    l = []
    if num < 0:
        return "-" + dec2oct(abs(num))
    while True:
        num, remainder = divmod(num, 8)
        l.append(str(remainder))
        if num == 0:
            return "".join(l[::-1])

十进制到十六进制：

base = [str(x) for x in range(10)] + [ chr(x) for x in range(ord("A"),ord("A")+6)]
def dec2hex(num):
    l = []
    if num < 0:
        return "-" + dec2hex(abs(num))
    while True:
        num,rem = divmod(num, 16)
        l.append(base[rem])
        if num == 0:
            return "".join(l[::-1])

1.标志符是高级程序设计语言必须使用的用来代表数据的符号。Python语言规定标志符只能以字母或下画线引导，其后跟随0个或多个非空格字符、下画线或数字，并且是大小写敏感的。它不能与Python语言的关键字（Python语言中已经定义过的字）相同。

2.在程序设计中需要自定义变量名、函数名、类名等名称。

“=”的作用是将对象引用与内存中某对象进行绑定。如果对象已经存在，就简单地进行绑定，以便引用右边的对象；若对象不存在，就由“=”操作符创建对象并绑定。

x = 3        #内存中还不存在3，则在内存中创建3，并将x与之绑定。此时x引用3
y = 3        #内存已存在3，则直接将y与内存中的3进行绑定。
             #此时x与y同时绑定了内存中同一个对象3
y = x + 5    #此操作会计算右边的值为8，内存中不存在8，则在内存中创建8，将y绑定到它。

x = 2
y = 2
print(x is y)        #结果为True，x和y引用同一个对象，所以结果为True
x = "a"              #x被重新绑定到一个字符串值上（原来绑定的是整数2）
y = 3.45             #y被重新绑定到一个浮点数值上（原来绑定的是整数2）
print("x")           #显示x绑定的值 "a"
print("y")           #显示y绑定的值 3.45

x = 2
y = "a"
x + y                              #x为整数，y为字符串，运算时引发错误

Python语言中结构数据类型有很多种，但最常用的主要有列表、元组和字典。

列表是以方括号“[]”包围的数据集合，不同成员间以“,”（半角符号）分隔。列表中可以包含任何数据类型，也可包含另一个列表。列表也可以通过序号来访问其中的成员。

list()                         #创建一个空列表[]
　　
[]                             #创建一个空列表[]
　　
[1,]                           #创建一个只有一个元素的列表[1]
　　
[1,2,3]                        #创建一个有三个元素的列表[1, 2, 3]
　　
alist = ["a",1,"b",2.0]        #创建一个包含不同数据元素的列表
alist[2]                       #访问列表alist中的第3个元素（序号为2）"b"
　　
[1,2]+ [3,4]                   #列表支持加法运算[1, 2, 3, 4]
　　
[None] * 5                     #列表支持乘法运算[None, None, None, None, None]

列表的操作函数

注意

在列表操作中并不返回列表，而只是修改列表。

元组可以看成是一种特殊的列表，与列表不同的是元组一旦建立就不能改变。既不能改变其中的数据项，也不能添加和删除数据项。因此，想让一组数据不能被改变就把它们放入到一个元组中即可，并且任何企图修改元组的操作都会发生错误的。（只读的列表，可以用列表的方式去查看）

元组的基本形式是以圆括号“()”括起来的数据元素，它也可以通过序号来引用其中的元素。

()                              #创建空元组()
　　
tuple()                         #创建空元组()
　　 
(1,)                            #创建只有一个元素的元组(1,)
　　
2,3                             #直接用逗号隔开两个值，可以创建一个元组(2, 3)
　　
x,y=2,3                         #右边为一元组，自动将元组第一个数值与x绑定，第二个与y绑定

x,y=y,x                         #交换x与y的值（本质上右边是一个元组）

atpl = (1,2,3)
atpl [1]                        #引用元组的序号为1的元素2

注意

建立只有一个元素的元组，元素后要有一个“,”。
　　

1 字典中每个成员是以“键：值”对的形式存在的。
2 字典以大括号“{}”包围的以“键：值”对方式声明和存在的数据集合。与列表的最大不同在于字典是无序的，其成员位置只是象征性的，在字典中通过键来访问成员，而不能通过其位置来访问该成员。

{}                           #建立空字典{}
　　
dict()                       #建立空字典{}
　　
adct = {"a":1,"b":2,"c":3.4}
　
adct["a"]                    #用键名引用成员

adct[1]                      #试图用序号引用字典成员，结果发生错误

Traceback (most recent call last):
　　  File "", line 1, in 
　　    adct[l]
　　KeyError: 1
　　

dic.items() dict_items([("a", 1), ("b", 2), ("c", 3)])
dic.keys() dict_keys(["a", "b", "c"])
dic.values() dict_values([1, 2, 3])

字典例题：用三种方法编程实现初始化字典{"a":1,"b":2]，并设置其key为’c’的对应值为3。

alst=["a","b","c"]
number=[1,2,3]
dict={}.fromkeys(alst)
print(len(number))
for i in range(len(number)):
    dict[alst[i]]=number[i]
else:
    print(dict)

1.7.1 常用内置常量

None的意义正是其字面意义，即“无”，常用来表示没有值的对象。
True（真）与False（假）是Python的逻辑型数据。
Python中逻辑假包括False,None,0,"(空字符串),()(空元组),[](空列表)和{}(空字典)等，而其余任何值都视为真。
1.7.2 Python中逻辑运算符

与（and）、或（or）、非（not）
1.7.3 Python中比较运算符

注意

字符（串）也是可以进行大小比较的，其比较依据的是其ascii码。

1.7.4　Python中其他逻辑操作符
1．is和is not
有文献资料中称他们为身份操作符，is和is not都是二元操作符，用于判断左端与右端对象引用是否指向同一个对象。
2．in和not in
in和not in称为成员操作符，用于检查某个数据是否存在于某包含多个成员的数据类型（如字符串、列表、元组、字典等）之中。如果是成员关系，则in返回真；否则返回假；而not in则相反。

注意
成员操作符对于字典来说检查的是键成员而不是值成员。

字符串是字符的序列，列表和元组则是任意Python数据类型或对象的序列。元组是不可变的，字符串也是不可以变的（修改字符串就是重新创建一个字符串）。

对于任何一个序列，它们的元素都是有序的，都可以使用序号来获取每一项成员的值，这在前面都已经讲述。另一方面Python中序列的序号既可以从左至右从0开始计数，又可以从右至左从-1开始计数。如图3.8所示，序列共有8个元素，从左至右数为0至7，从右至左数为-1至-8。

以序号来取序列成员的话，同一成员可以有两个序号取法。

序列的切片是指用形如[start:end:step]来取序列中的部分成员数据项。
意思是从序列中start序号开始到end前一个结束，每隔step个取一个成员。

例子：alst=[0,l,2,3,4,5,6,7]

alst = [0,1,2,3,4]
sum (alst,15)           #求所有元素的和，连同15一起加起来
#25
all (alst)
#False
any(alst)
#True
sum(alst[0:3])
#3