python3_03.数据类型
1.数据类型
Python3 中有六个标准的数据类型：
1.1、Number（数字）
int、float、bool、complex（复数）。
注意：不同类型的数混合运算时会将整数转换为浮点数
1.2、String（字符串）
Python中的字符串用单引号(')或双引号(")括起来，同时使用反斜杠(\)转义特殊字符。
Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。
注意：
- 反斜杠可以用来转义，使用r可以让反斜杠不发生转义，r'\temp' 。
- 字符串可以用+运算符连接在一起，用*运算符重复。
- Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
- Python中的字符串不能改变。
str.upper() | 全部大写 |
|---|---|
str.lower() | 全部小写 |
str.swapcase() | 大小写转换 |
str.capitalize() | 首字母大写 |
str.title() | 每个单词的首字母大写 |
str.find('t',start,end) | 查找字符串，可以指定起始及结束位置搜索,没有返回-1 |
str.rfind('t') | 从右边开始查找字符串 |
str.replace('old','new') | 替换函数，替换old为new，参数中可以指定maxReplaceTimes，即替换指定次数的old为new |
str.strip() | 去两边空格 |
str.lstrip() | 去左空格 |
str.rstrip() | 去右空格 |
str.startswith('start') | 是否以start开头 |
str.endswith('end') | 是否以end结尾 |
str.isalnum() | 是否全为字母或数字 |
str.isalpha() | 是否全字母 |
str.isdigit() | 是否全数字 |
str.islower() | 是否全小写 |
str.isupper() | 是否全大写 |
#print字符串拼接:
>>> print("hello"+"andy")
helloandy
>>> print("hello","andy")
hello andy <,号会有一个空格>
>>> print("hello"*2)
hellohello
#join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
>>> list=['I','love','you']
>>> ''.join(list)
'Iloveyou'
>>> ' '.join(list)
'I love you'
>>> ','.join(list)
'I,love,you'
>>> love = 'I love you'
>>> love.split() #默认是以空格为分隔符分割
['I', 'love', 'you']
>>> love.split(' ',2) #以空格为分隔符，最大分割次数为2
['I', 'love', 'you']
>>> love.split(' ',1) #以空格为分隔符，最大分割次数为1
['I', 'love you']转义字符 | 描述 |
|---|---|
\(在行尾时) | 续行符 |
\\ | 反斜杠符号 |
\' | 单引号 |
\" | 双引号 |
\a | 响铃 |
\b | 退格(Backspace) |
\e | 转义 |
\000 | 空 |
\n | 换行 |
\v | 纵向制表符 |
\t | 横向制表符 |
\r | 回车 |
\f | 换页 |
\oyy | 八进制数，yy代表的字符，例如：\o12代表换行 |
\xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
\other | 其它的字符以普通格式输出 |
#python字符串格式化:
"this is %d %s bird" % (1, 'dead') # 一般的格式化表达式
"%s---%s---%s" % (42, 3.14, [1, 2, 3]) # 字符串输出：'42---3.14---[1, 2, 3]'
"%d...%6d...%-6d...%06d" % (1234, 1234, 1234, 1234) # 对齐方式及填充："1234... 1234...1234 ...001234"
x = 1.23456789
"%e | %f | %g" % (x, x, x) # 对齐方式："1.234568e+00 | 1.234568 | 1.23457"
"%6.2f*%-6.2f*%06.2f*%+6.2f" % (x, x, x, x) # 对齐方式：' 1.23*1.23 *001.23* +1.23'
"%(name1)d---%(name2)s" % {"name1":23, "name2":"value2"} # 基于字典的格式化表达式
"%(name)s is %(age)d" % vars() # vars()函数调用返回一个字典，包含了所有本函数调用时存在的变量
"{0}, {1} and {2}".format('spam', 'ham', 'eggs') # 基于位置的调用
"{motto} and {pork}".format(motto = 'spam', pork = 'ham') # 基于Key的调用
"{motto} and {0}".format(ham, motto = 'spam') # 混合调用
# 添加键 属性 偏移量 (import sys)
"my {1[spam]} runs {0.platform}".format(sys, {'spam':'laptop'}) # 基于位置的键和属性
"{config[spam]} {sys.platform}".format(sys = sys, config = {'spam':'laptop'}) # 基于Key的键和属性
"first = {0[0]}, second = {0[1]}".format(['A', 'B', 'C']) # 基于位置的偏移量
# 具体格式化
"{0:e}, {1:.3e}, {2:g}".format(3.14159, 3.14159, 3.14159) # 输出'3.141590e+00, 3.142e+00, 3.14159'
"{fieldname:format_spec}".format(......)
# 说明:
"""
fieldname是指定参数的一个数字或关键字, 后边可跟可选的".name"或"[index]"成分引用
format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type]
fill ::= <any character> #填充字符
align ::= "<" | ">" | "=" | "^" #对齐方式
sign ::= "+" | "-" | " " #符号说明
width ::= integer #字符串宽度
precision ::= integer #浮点数精度
type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
"""
# 例子:
'={0:10} = {1:10}'.format('spam', 123.456) # 输出'=spam = 123.456'
'={0:>10}='.format('test') # 输出'= test='
'={0:<10}='.format('test') # 输出'=test ='
'={0:^10}='.format('test') # 输出'= test ='
'{0:X}, {1:o}, {2:b}'.format(255, 255, 255) # 输出'FF, 377, 11111111'
'My name is {0:{1}}.'.format('Fred', 8) # 输出'My name is Fred .' 动态指定参数符 号 | 描述 |
|---|---|
%c | 格式化字符及其ASCII码 |
%s | 格式化字符串： 'a %s parrot' % 'kind' |
%d | 格式化整数 |
%u | 格式化无符号整型 |
%o | 格式化无符号八进制数 |
%x | 格式化无符号十六进制数 |
%X | 格式化无符号十六进制数（大写） |
%f | 格式化浮点数字，可指定小数点后的精度 |
%e | 用科学计数法格式化浮点数 |
%E | 作用同%e，用科学计数法格式化浮点数 |
%g | %f和%e的简写 |
%G | %f 和 %E 的简写 |
%p | 用十六进制数格式化变量的地址 |
1.3、List（列表）
注意：
1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，list可以被索引和切片。
3、List可以使用+操作符进行拼接，星号（*）是重复操作。
4、List中的元素是可以改变的。
list=[] | 创建一个空列表 |
|---|---|
list.append('zengjia') | 在列表末尾添加一个元素，返回值为none |
list.extend([7,8,9]) | extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。 |
list.insert(6,'six') | 指定位置插入 |
del list[6] | 删除指定位置元素 del a[2:4] del a[:] |
list.pop() | 删除指定位置的值并返回删除的值 默认最后一个 |
list.clear() | 清空列表 |
list.sort() | 排序 |
list.reverse() | 原地反转列表 |
list.remove(1) | 删除首次出现的指定元素 1 |
list.index(22) | 查看元素第一次出现的位置 |
list.count(1) | 指定元素1出现的次数 |
list.copy() | 返回列表的浅复制，等于a[:]。 |
len(list) | 列表长度 |
切片：用切片查看元素不会因为越界抛出异常，代码具有更强的健壮性 | |
cc=[0,1,2,3,4,5,6,7,8,9,10] | |
cc[::] | [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] |
cc[0:11:1] | [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] |
cc[::-1] | [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0] |
cc[::2] | [0, 2, 4, 6, 8, 10] |
cc[len(cc):]='a' #切片增加元素 | [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a'] |
cc[:3]=['a','b','c'] #切片修改元素 | ['a', 'b', 'c', 3, 4, 5, 6, 7, 8, 9, 10] |
collections.deque | 它为在首尾两端快速插入和删除而设计。 |
for i, v in enumerate(['tic', 'tac', 'toe']):... print(i, v) | 在序列中循环时，索引位置和对应值可以使用 enumerate() 函数同时得到: |
>>> questions = ['name', 'quest', 'favorite color']>>> answers = ['lancelot', 'the holy grail', 'blue']>>> for q, a in zip(questions, answers):... print('What is your {0}? It is {1}.'.format(q, a)) | 时循环两个或更多的序列，可以使用 zip() 整体打包: |
Python的List功能已经足够完成队列的功能, 可以用 append() 来向队尾添加元素, 可以用类似数组的方式来获取队首元素, 可以用 pop(0) 来弹出队首元素. 但是List用来完成队列功能其实是低效率的, 因为List在队首使用 pop(0) 和 insert() 都是效率比较低的, Python官方建议使用collection.deque来高效的完成队列任务.
from collections import deque
queue = deque(["Eric", "John", "Michael"])
queue.append("Terry") # Terry 入队
queue.append("Graham") # Graham 入队
queue.popleft() # 队首元素出队 #输出: 'Eric'
queue.popleft() # 队首元素出队 #输出: 'John'
queue # 队列中剩下的元素 #输出: deque(['Michael', 'Terry', 'Graham'])列表生成式
Python内置的非常简单却强大的可以用来创建list的生成式。
>>> list(range(1,21))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> L = []
>>> for x in range(1,11):
... L.append(x*x)
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> [x * x for x in range(1,11)] #一行的高级写法
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> [x * x for x in range(1,11) if x %2 == 0] #加上if判断，筛选出偶数的平方
[4, 16, 36, 64, 100]
>>> [(x,y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]1.4、Tuple（元组）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改，所以没有增删改操作。元组写在小括号(())里，元素之间用逗号隔开。
#元组是不可变的，所以初始化后元组内的元素不可改变。
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
1234 | t = tuple() # 构造一个空元组t = () 也是构造一个空元组t = (1,) 初始化一个元素的元组，一个元素必须要加逗号t = (1, 2, 3) # 初始化三个元素的元组 |
|---|
注意：
1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含0或1个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。
string、list和tuple都属于sequence（序列）。
1.5、Sets（集合）
集合（set）是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号({})或者 set()函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
s = set() # 用set函数定义空集合
s = {} ！！！这是字典
1.6、Dictionary（字典）
列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。
常用字典常量和操作
D = {}
D = {'spam':2, 'tol':{'ham':1}} # 嵌套字典
D = dict.fromkeys(['s', 'd'], 8) # {'d': 8, 's': 8}
D = dict(name = 'tom', age = 12) # {'age': 12, 'name': 'tom'}
D = dict([('name', 'tom'), ('age', 12)]) # {'age': 12, 'name': 'tom'}
D = dict(zip(['name', 'age'], ['tom', 12])) # {'age': 12, 'name': 'tom'}
D.keys() D.values() D.items() # 字典键、值以及键值对
D.get(key, default) # get函数,指定键的值
D.update(D_other) # 合并字典，如果存在相同的键值，D_other的数据会覆盖掉D的数据
D.pop(key, [D]) # 删除字典中键值为key的项，返回键值为key的值，如果不存在，返回默认值D，否则异常
D.popitem() # pop字典中的一项（一个键值对）
D.setdefault(k[, d]) # 设置D中某一项的默认值。如果k存在，则返回D[k]，否则设置D[k]=d，同时返回D[k]。
del D # 删除字典
del D['key'] # 删除字典的某一项
if key in D: if key not in D: # 测试字典键是否存在
# 字典注意事项：（1）对新索引赋值会添加一项（2）字典键不一定非得是字符串，也可以为任何的不可变对象一些写法： | |
|---|---|
{x:x**2 for x in (2,4,6)} | {2: 4, 4: 16, 6: 36} |
{k:8 for k in ['s','d']} | {'s': 8, 'd': 8} |
{k:v for (k,v) in zip(['name','age'],['tom',12])} | {'age': 12, 'name': 'tom'} |
dict(sape=4139, guido=4127, jack=4098) | {'jack': 4098, 'guido': 4127, 'sape': 4139} |
字典遍历： | |
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}>>> for k, v in knights.items():... print(k, v) | 在字典中循环时，关键字和对应的值可以使用 items() 方法同时解读出来: |
import collections | collections.OrderedDict() | 这个模块可以记录字典的输入顺序，遍历按输入顺序输出。 |
附：
- 迭代：如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）。
- Python中的索引，从前往后，索引是从0开始，从后往前，索引是从-1开始。
- 如果索引超出范围，将引发IndexError异常。
2.数据类型转换
函数 | 描述 |
|---|---|
int(x [,base]) | 将x转换为一个整数 |
float(x) | 将x转换到一个浮点数 |
complex(real [,imag]) | 创建一个复数 |
str(x) | 将对象 x 转换为字符串 |
repr(x) | 将对象 x 转换为表达式字符串 |
eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
tuple(s) | 将序列 s 转换为一个元组 |
list(s) | 将序列 s 转换为一个列表 |
set(s) | 转换为可变集合 |
dict(d) | 创建一个字典。d 必须是一个序列 (key,value)元组。 |
frozenset(s) | 转换为不可变集合 |
chr(x) | 将一个整数转换为一个字符 |
unichr(x) | 将一个整数转换为Unicode字符 |
ord(x) | 将一个字符转换为它的整数值 |
hex(x) | 将一个整数转换为一个十六进制字符串 |
oct(x) | 将一个整数转换为一个八进制字符串 |