python基本类型

Python提供的基本数据类型主要有：空类型、布尔类型、整型、浮点型、字符串、列表、元组、集合、字典。

整型（Int）

整型，一般就是表示整数。在Python中，没有特别区分长整型和整型。一般超过32位之后，就自动当做长整型来处理。长整型在python中几乎没有范围限制。

浮点数（Float）

也就是C语言中的double，java中的float和double。在运算中，整数和浮点数的运算结果也是浮点数。

注： // 表示对结果取整，直接舍弃小数点后面的数值。

字符串

在python中，被单引号'或者双引号"或者三引号"""包围起来的字符序列即为字符串。和其他语言一样，使用\进行转义。

在python中可以使用r或者u来修饰字符串。
使用r/R修饰表示后面跟着的就是普通字符串。即，如果字符串中包含\n那么它也就是一个反斜杠字符和一个字母n，而不是表示换行符。

使用u/U修饰字符串表示unicode字符串。Unicode是书写国际文本的标准方法。如果你想要用非英语写文本,那么你需要有一个支持Unicode的编辑器。
类似地,Python允许你处理Unicode文本——你只需要在字符串前加上前缀u或U。

字符串运算

使用+号拼接字符串

乘法运算

自动拼接

使用len()方法求字符串长度

取字符串对应下标的字符
同其他语言一样，字符串的索引是从0开始，到str.length - 1为止，超过就越界。

其他字符串用法可参见python字符串内建函数

列表

列表是python的基本数据结构之一，也是最常用的数据结构。和CPP、Java等语言不同，python的列表数据项不需要具有相同的类型。列表中的每个元素都分配一个数字-它的位置，或者索引，第一个索引是0，第二个索引是1，依次类推。

创建列表

foods = [] #创建空列表
foods = [1, 2, 3, 4, 5] # 创建整型列表
foods = ['a', 'b', 'c', 'd', 'e'] # 创建字符型列表
foods = [1, 2, 3, 'd', 1.2] # 创建混合列表

还可以使用列表生成式来生成列表

foods = [x * x for x in range(5)]
foods = [x ** x for x in range(10) if x % 2 == 0]

访问列表

使用for…in…迭代列表

foods = [1, 2, 3, 4, 5]
for food in foods:
    print(food)

使用索引取列表指定位置元素

foods = [1, 2, 3, 4, 5]
print(foods[0])
print(foods[5])

更新列表

可以对列表的数据项进行修改或者更新，也可以对列表进行增删。

foods = []    # 生成一个空列表
foods.append(1)    # 向列表追加 1
foods.append(2)    # 向列表追加 2
foods[1] = 3    # 将列表第二个元素值修改为 3
fruits = []    # 生成另一个空列表
fruits.extend(food)    # 用foods列表来扩展fruits列表
fruits.append('apple')    # 在fruits列表末追加 apple 项

删除列表

使用del关键字删除列表元素

列表分片

python中使用索引来取列表中特定位置的值。分片操作就是用来取一定范围内的值，它通过在方括号内用冒号隔开两个索引来实现，第一个索引是开始点，包括在结果之中，第二个索引的元素是结束点，不包括在结果之中。即，它取的是一个前闭后开的区间。

string = 'www.python.org'    # 字符串也是一个列表
string[4:10]    #取列表索引为4，到索引为10的，前闭后开区间中的字符串
string[4:-4]    # 取列表索引为4，到从后往前第4个区间中的字符串
string[:-1]    # 取索引为0，到最后一个字符为止，区间中的字符串
string[::-1]    # -1 表示步长，即从末尾到首部，依次输出字符
string[-1]    # 取最后一个字符
string[-3]    # 取最后第3个字符

分片可以接受3个参数l[x:y:z]，其中x表示起始索引，如果留空，默认为列表的头部，同理，y留空，默认为列表的尾部，z表示步长，默认为1。

其他操作

foods = [x for x in range(5)]    # 生成一个列表，[1, 2, 3, 4, 5]
print(len(foods))    # 计算列表长度
[1, 2, 3] + [4, 5]    # 拼接两个列表
[1] * 5    # 复制列表元素
3 in [1] * 5    # false 3 是否在列表 [1] * 5 中

字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

d = {}    # 生成空字典
d
d = {'a': 1, 'b': 2, 'b': '3'}
d['b']    # 从字典取键为b的值
d

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

一个简单的字典实例：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

也可如此创建字典：

dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }

添加元素

字典可以使用任意不变的对象作为键值，字符串、整型、元组等。列表是不可作为键值的，因为它是可变对象。

d = {}
d['name'] = 'huhansan'
d['huhansan'] = "name" 
d[(1, 2, 3)] = 'tuple'    # 使用元组做键值

访问和遍历元素

可以直接使用键值key取字典中对应的值，也可以只用dict.keys()和dict.item()来遍历获取字典中所有键值对。

d = {}
d['name'] = 'huhansan'
d['huhansan'] = "name" 
d[(1, 2, 3)] = 'tuple'
print(d['name'])
for key in d.keys():    # 调用keys 遍历字典
    print(d[key])

for key, value in d.items():    # 调用items 获取键值对
	print(key, value)

如果访问一个不在字典中的键值对，则会抛出一个异常。

d = {}
d['name'] = 'huhansan'
d['huhansan'] = "name" 
d[(1, 2, 3)] = 'tuple'
d[222]    # 获取不存在的元素，此处会抛出一个异常

删除元素

使用python内置关键字del删除字典内元素；也可以调用字典内置函数clear() 清空字典元素。

d = {}
d['name'] = 'huhansan'
d['huhansan'] = "name" 
d[(1, 2, 3)] = 'tuple'
del d['name']    # 删除键为name的值
del d    # 删除字典 d
d    #    删除字典后，再访问，此处会抛出一个异常

修改元素

向字典中重复添加相同元素的键值对，后添加的键值对值会覆盖前添加的键值对的值。

d = {}
d["name"] = "huhansi"
d["name"] = "huhansan"
print(d["name"])

其他操作

元组

在Python中，元组（Tuple）和列表类似，两者之间的区别在于：元组不能更改，列表可以。也就是说，一旦被分配，就不能从元组中添加、更改或者删除元素。

元素的优势

· 通常将元组用于不同的数据类型，将列表用于相同（或相似）的数据类型
· 由于元组不可变，所以遍历元组比列表要快（较小的性能提升）
· 元组可以用做字典的key，而列表不行。因为字典的key必须是不可变的，元组本身就是不可变的
· 如果数据不需要修改，可将其作为元组来实现，可以确保“写保护”
· 元组可以被用在字符串格式化中

创建元组

在Python中，元组的内置tuple类型定义。
要创建元组，需要将所有项（元素）放在括号（()）内，以逗号（,）分隔。括号是可选的，但是建议写上。

t = 1, 2, 3, 4, 5    # 创建元组，不使用括号
t = ()    # 空元组
t = ('p', 'y', 't', 'h', 'o', 'n')    # 字符型元组
t = (1, 1.2, "1.3")    # 混合型元组
t = (1, 2, (3, 4, 5))    # 嵌套型元组

另外，如果要声明一个元组的元组，在括号中单申明一个元素是不够的，要在该元组后面添加一个逗号。

t = ("python")    # 此语法无法声明一个单元素元组，只会申明一个字符串
type(t)
t = ("python",)    # 此语法才可声明一个单元素元组
type(t)

元组分片

元组和列表都属于序列，因此，他们的基本操作是一样的。可以使用索引操作符[]来访问元组中的每一个元素，使用切片操作符：来访问元组中的一系列元素。

t = (1, 2, 3, 4, 5, 6, 7, 8)
t[1]    # 取元组第一个元素
t[-2]    # 取元组第七个元素
t = (1, 2, 3, (4, 5, 6))    # 元组嵌套
t[3][2]    # 取元素第四个元素元组中的第三个元素
t = (1, 2, 3, [7, 8, 9])    # 元组嵌套列表
t[3][2]    # 取元素第四个元组列表中的第三个元素
t[1:3]    # 取元组第二个到第三个元素
t[1:]    # 取元组第二个到元组末尾的序列
t[:4]    # 取元组头开始到元素第四个元素的序列

更改元组

元组是不可变的，也就是说，元组中的元组在被赋值后不能改变。
但是，如果元素本身是一个可变数据类型的列表，那么其嵌套项可以被改变。

t = (1, 2, 3, [4, 5, 6])
t[0] = 7
t[3][0] = 8

删除元组

元组元素不能修改，那么元组中的元素也是不能删除的，但是可以删除整个元组。

t = (1, 2, 3, 4, 5, 6, 7, 9)
del t[1]
del t
t

元组和列表互换

元和和列表可以互相转换，分别使用list()和tuple()方法实现。

t = (1, 2, 3, 4, 5, 6)
listt = list(t)    # 将元组转换为列表
t = tuple(listt)    # 将列表转换为元组

集合

集合（Set）也是标准的Python数据类型，它也可以用于存储值。它和列表或者元组之间的区别是，集合中的每一个元素不能出现多次，并且元素之间是无序存储的。
由于集合中的元素不能出现多次，这使得集合在很大程度上能够高效地从列表或者元组中删除重复值，并执行取并集、交集等常见的数学操作。

创建集合

s = set()    # 声明空集合
s = set("python")    # 以字符列表，字符串形式声明集合
s = set([1, 2, 3, 4])    # 以列表形式声明集合
s = {1, 2, 3, 4}    # 以花括号形式声明集合
s = {1, 1, 2, 3}    # 如果集合中有重复元素，那么重复元素只会出现一次，即，此时，s = {1, 2, 3}

查询和遍历集合

s = set([1, 2, 3, 4])
print(4 in s)
for value in s:
    print(value)

删除集合

s = set([1, 2, 3, 4, 5, 6])
s.remove(1)    # 移除元素1
s.add(7)
del s
s

空类型（None）

表示该值是一个空值，且对其没有特别的操作。空值是Python里的一个特殊的值，用None表示。空值不能理解为0，因为0是有意义的，而None是一个特殊的空值。

None == 0
None == ''
type(None)
None == None
None is None