共计 1648 个字符，预计需要花费 5 分钟才能阅读完成。

print(type(18))        #<class‘int'>
print(type(5.6))    #<class'float'>
print(type('Hello'))#<class'str'>

print(118)            #118
print(0b1110110)    #118
print(00166)        #118
print(0×76)            #118

print(bin(118))        #0bl110110
print(oct(118))        #00166
print(hex(118))        #0x76

  print(int())            #0
  print(int(118))            #118
  print(int(118.2))        #118
  print(int('118'))        #118
  print(int('1110110',2))    #118
  print(int('00166',8))    #118
  print(int('0x76',16))    #118

     print(0.123456789)        #0.123456789

不传递任何参数时，返回浮点数 `0.0`
只传递一个参数时，将传递的参数转换为浮点数

print(float())        #0.0
print(float(118))    #118.0
print(float(118.2))    #118.2
print(float('118'))    #118.0

print(2.3e8)        #230000000.0
print(2.3e-4)        #0.0002311u

print(1.1+2.2-3.3)        #4.440892098500626e-16
print(1.1+2.2)        #3.3000000000000003111111

from decimal import Decimal 
print(Decimal('1.1')+Decimal('2.2')-Decimal('3.3'))        #0.0
from fractions import Fraction 
print(Fraction(11，10)+Fraction(22，10)-Fraction((33，10))        #0

print(5>3)    #True 
print(5<3)    #False

  print(True1)        #True 
  print(False==0)        #True
  print(True+False+5)    #6

共计 225 个字符，预计需要花费 1 分钟才能阅读完成。

常用数据类型 Common Data Types

类型
例子

整数
-100

浮点数
3.1416

字符串
‘hello’

列表
[1, 1.2, ‘hello’]

字典
{‘dogs’: 5, ‘pigs’: 3}

Numpy 数组
array([1, 2, 3])

其他类型 Others

类型
例子

长整型
1000000000000L

布尔型
True, False

元组
(‘ring’, 1000)

集合
{1, 2, 3}

Pandas 类型
DataFrame, Series

自定义
Object Oriented Classes

共计 7196 个字符，预计需要花费 18 分钟才能阅读完成。

1.python 的数据类型：

字符串
整数
浮点数
类型转换
字符串编码
列表、元组与字典

2. 应用：

序列及其通用操作
相关逻辑运算

1.1 字符串（Str）
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\nabc’ #包含一个换行符的字符串
‘abc\’2\’abc’ #字符串中包含被单引号引起的 2

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

字符串操作
描述

string.capitalize()
将字符串的第一个字母大写(返回新的值，不修改原值)

string.count()
获得字符串中某一子字符串的数目

string.find()
获得字符串中某一子字符串的起始位置，无则返回—1

string.isalnum()
检测字符串是否只由 0 -9A-Za-z

string.isalpha()
检测字符串是仅包含 A -Za-z

string.isdigit()
检测字符串是仅包含数字

string.islower()
检测字符串是否均为小写字母

string.isspace()
检测字符串中所有字符是否均为空白字符

string.istitle()
检测字符串中的单词是否为首字母大写

string.isupper()
检测字符串是否均为大写字母

string.join()
连接字符串

string.1ower()
将字符串全部转换为小写

string.split()
分割字符串

string.swapcase()
将字符串中大写字母转换为小写，小写字母转换为大写

string.tit1e()
将字符串中的单词首字母大写

string.upper()
将字符串中全部字母转换为大写

len(string)
获取字符串长度

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

其参数含义如下：
sep 可选参数，指定分割的字符，默认为空格；
maxsplit 可选参数，分割次数。

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

原始字符串表示方式及使用
如何格式化字符串
中文字符串的使用

1. 原始字符串表示方式及使用防止转义字符输入过多而使代码阅读性下降
print(r’abc\nabc’)
result:abc\nabc

print(‘abc\nabc’)
result:abc
abc
注意:
原始字符串不得以“”结尾。见图 3.5 所示的第三行（第二个示例）及后面错误提示。
2. 如何格式化字符串

格式化串
意义

%c
单个字符

%d
十进制整数

%o
八进制整数

%s
字符串

%x
十六进制整数，其中的字母小写

%X
十六进制整数，其中的字母大写

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 要一致，否则不能还原或报错。
1.2 整数（int）

0o[0O]数字 表示八进制整数（例如：0O24、0O24）
0x[0X]数字 表示十六进制整数（例如：0x3F、0X3F）
0b[0B]数字 表示二进制整数（例如：Obl01、0B101）

运算符
描述

**
乘方运算符

*
乘法运算符

/
除法运算符

//
整除运算符

%
取余运算符

+
加法运算符

–
减法运算符

︳
位或

^
位异或

&
位与

<<
左移运算

>>
右移运算

“//”运算符就是取商而丢弃余数，比如 14÷4=3……2，所以 14//4=3；而“%”运算符的运算结果是余数而丢弃商，所以 14%4=2;“/”运算符的运算结果为浮点数，即使是两个整数相除。
|、^、&、<<、>> 运算符都是位运算符，要依据其二进制形式进行运算
运算符优先级从高到低排列如下：

**
*、/、%
+、-
|、^、&、<<、>>

没有把握的情况下可以运用括号。
1.3 浮点数（float）

19.
小数部分为零，可以不写；

.098
整数部分为零，可以不写；

-2e3
科学计数法，表示—2×103

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

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.5 标志符与赋值号
1.5.1 标志符
1. 标志符是高级程序设计语言必须使用的用来代表数据的符号。Python 语言规定标志符只能以字母或下画线引导，其后跟随 0 个或多个非空格字符、下画线或数字，并且是大小写敏感的。它不能与 Python 语言的关键字（Python 语言中已经定义过的字）相同。
2. 在程序设计中需要自定义变量名、函数名、类名等名称。
1.5.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 为字符串，运算时引发错误

1.6 Python 结构数据类型
Python 语言中结构数据类型有很多种，但最常用的主要有列表、元组和字典。
1.6.1 列表（list）
列表是以方括号“[]”包围的数据集合，不同成员间以“,”（半角符号）分隔。列表中可以包含任何数据类型，也可包含另一个列表。列表也可以通过序号来访问其中的成员。
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]
列表的操作函数

列表操作
描述

list.append(x)
列表尾部追加成员 x,x 作为一个整体添加进列表（列表做整体）

list.count(x)
返回列表中的参数 x 出现的次数

list.extend(L)
将列表 L 中的元素取出来追加到原列表尾部

list.index(x)
返回参数 x 在列表中的序号（x 不存在则报错）

list.insert(index,object)
向列表中指定位置（index）前面插入数据（object）插入方式与 append 相同将对象作为整体（列表做整体）

list.pop()
删除列表中尾部的成员并返回删除的成员

list.remove(x)
删除列表中的指定成员（有多个则只删除第一个）指定成员不存在则报错

list.reverse()
将列表中成员的顺序颠倒（原列表上执行)

list.sort()
将列表中成员排序（要求其成员可排序，否则报错）默由小到大, 可以使用 reverse 函数由大到小修改。

注意
在列表操作中并不返回列表，而只是修改列表。
1.6.2 元组（tuple）
元组可以看成是一种特殊的列表，与列表不同的是元组一旦建立就不能改变。既不能改变其中的数据项，也不能添加和删除数据项。因此，想让一组数据不能被改变就把它们放入到一个元组中即可，并且任何企图修改元组的操作都会发生错误的。（只读的列表，可以用列表的方式去查看）
元组的基本形式是以圆括号“()”括起来的数据元素，它也可以通过序号来引用其中的元素。
() #创建空元组()

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.6.3 字典（dict）
1 字典中每个成员是以“键：值”对的形式存在的。2 字典以大括号“{}”包围的以“键：值”对方式声明和存在的数据集合。与列表的最大不同在于字典是无序的，其成员位置只是象征性的，在字典中通过键来访问成员，而不能通过其位置来访问该成员。
{} #建立空字典{}

dict() #建立空字典{}

adct = {‘a’:1,’b’:2,’c’:3.4}

adct[‘a’] #用键名引用成员

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

Traceback (most recent call last):
File “<pyshell#99>”, line 1, in <module>
adct[l]
KeyError: 1

字典操作
描述

dic.clear()
清空字典

dic.copy()
复制字典

▲dic.get(k,[default])
获得键 k 对应的值，不存在则返回 default

dic.items()
获得由键和值组成的迭代器

dic.keys()
获得键的迭代器

dic.values()
获得值的迭代器

▲dic.pop(k)
删除 k:v 成员对, 并返回删除 key 对应的值

▲dic.update(adict)
从另一个字典更新成员（不存在就创建，存在则覆盖）

dic.fromkeys(iter,value)
以列表或元组中给定的键建立字典，默认值为 value

dic.popitem()
从字典中删除任一 k:v 项并返回它

▲dic.setdefault(k,default)
若字典中存在 key 值为 k 的，则返回其对应的值；否则，在字典中建立一个 k:default 字典成员

dic.items() dict_items([(‘a’, 1), (‘b’, 2), (‘c’, 3)]) dic.keys() dict_keys([‘a’, ‘b’, ‘c’]) dic.values() dict_values([1, 2, 3])
1.7 内置常量与逻辑运算符、比较运算符
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 inin 和 not in 称为成员操作符，用于检查某个数据是否存在于某包含多个成员的数据类型（如字符串、列表、元组、字典等）之中。如果是成员关系，则 in 返回真；否则返回假；而 not in 则相反。
注意成员操作符对于字典来说检查的是键成员而不是值成员。
1.8 序列
字符串是字符的序列，列表和元组则是任意 Python 数据类型或对象的序列。元组是不可变的，字符串也是不可以变的（修改字符串就是重新创建一个字符串）。
1.8.1 序列切片
对于任何一个序列，它们的元素都是有序的，都可以使用序号来获取每一项成员的值，这在前面都已经讲述。另一方面 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[:]
取全部成员数据项

alst[0:]
取全部成员数据项

alst[:-1]
取除最后一个成员之外的所有成员数据项

alst[2:5]
得到[2,3,4]

▲alst[::2]
每隔 1 个取一个成员，得到[0,2,4,6]

alst[0:5:2]
从 0 至 4 每隔一个取一项，得到[0,2,4]

▲alst[::-l]
从右至左取全部成员，得到[7,6,5,4,3,2,1,0]

alst[5:0:-2]
从 5 至 0（不包括 0）从右至左每隔一个成员取一个成员，得到[5,3,1]

1.8.2 序列内置操作

方 法
操作方法

len(s)
返回 s 的元素数（长度）

min(s)
返回 s 中的最小值

max(s)
返回 s 中的最大值

sum(s[,start]
返回 s 中各项的和

all(s)
s 中所有项为真，则返回真，否则返回假

any(s)
s 中有一项为真，则返回真，否则返回假

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