python3 数据类型

Python3 中有六个标准的数据类型：

Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Sets（集合）
Dictionary（字典）

Number（数字）

Python3 支持 int、float、bool、complex（复数）

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

像大多数语言一样，数值类型的赋值和计算都是很直观的。

内置的type()函数可以用来查询变量所指的对象类型。

数值运算

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32

注意：

1、Python可以同时为多个变量赋值，如a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
3、数值的除法（/）总是返回一个浮点数，要获取整数使用//操作符。
4、在混合计算时，Python会把整型转换成为浮点数。

String（字符串）

Python中的字符串用单引号(')或双引号(")括起来，同时使用反斜杠(\)转义特殊字符

字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号 (+) 是字符串的连接符，星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数

name = 'old\t Boy'
print(name.capitalize()) # 首字母大写
print(name.casefold()) # 大写变小写
print(name.center(30, '-')) # 30位空间，字符放中间，左右加符号填充空格
print(name.count('o',0,3)) # 0-3位置中找字符o
print(name.endswith('i')) # 找最后一位字符，判断真假
print(name.startswith('i')) # 找开头第一位字符，判断真假
print(name.expandtabs(20)) # 将\t替换成20位空格
print(name.find('oy'))
msg = 'my name is {0} and i am {1} years old'
msg2 = 'my name is {name} and i am {age} years old'
print(msg.format('boy', 22)) # 按顺序
print(msg2.format(age=33, name='old')) # 可不按顺序
#print(msg2.format_map())
print(msg.isalpha()) # 是不是全英文字母，判断真假
print(msg2.isalnum()) # 是否包含字母或数字，判断真假
print('2'.isdecimal()) # 是否是十进制，小数
print('2'.isdigit()) # 是否是正整数
print('al_ex'.isidentifier()) # 是否是合法变量名
print('al_ex'.isupper()) # 是否大写
print('al_ex'.islower()) # 是否小写
print('3.1'.isnumeric()) # 是否小数
print('My Name Is'.istitle()) # 是否是标题（要求首字母大写）
print(','.join(msg)) # 连接起来
print('-'.join(['abc','def','and'])) #常用方法
print('old boy'.ljust(30,'-')) # 类center，居左，不够的字符补齐
print('old boy'.rjust(30,'-')) # 类center，居右，不够的字符补齐

List（列表）

List（列表）是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号([])之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

>>> list = ['a','b',3.14,'haha',88]
>>> list2 = ['woleigequ', 798]
>>> list
['a', 'b', 3.14, 'haha', 88]
>>> list2
['woleigequ', 798]
>>> list[0]
'a'
>>> list[2:]
[3.14, 'haha', 88]
>>> list2 * 2
['woleigequ', 798, 'woleigequ', 798]
>>> list + list2
['a', 'b', 3.14, 'haha', 88, 'woleigequ', 798]
# 增加
>>> list2.append('you win')
>>> list2
['woleigequ', 798, 'you win']
# 修改
>>> list[1] = 'Tianjin'
>>> list
['a', 'Tianjin', 3.14, 'haha', 88]
>>> list.pop()
88
>>> list
['a', 'Tianjin', 3.14, 'haha']
# 删除

>>> list = ['a','b',3.14,'haha',88]
>>> list.remove('haha')
>>> list
['a', 'b', 3.14, 88]
>>> del list[1]
>>> list
['a', 3.14, 88]
>>> list = ['a','b',3.14,'haha',88]
>>> list[0::2]
['a', 3.14, 88]
 
# 插入
 
>>> list.insert(2,'en')
>>> list
['a', 'b', 'en', 3.14, 'haha', 88]
 
#索引
 
>>> names[1:4] # 索引1-3位置元素
['Beijing', 'Beijing', '5']
>>> names[-1] # 最后一位元素
'!'
>>> names[-3:-1] # 倒数第三位到倒数第二个
['Beijing', '5']
>>> names[-3:] # 倒数第三位到最后
['Beijing', '5', '!']
>>> names[0:5]
['Chongqing', 'Beijing', 'Beijing', '5', '!']
>>> names[0:5:2] # 步长为2，相当于打印1，3，5
['Chongqing', 'Beijing', '!']
# 查找相同的第二个字符串
 
>>> list.append('en')
>>> list
['a', 'b', 'en', 3.14, 'haha', 88, 'en']
>>> first_index = list.index('en')
>>> second_index = list[first_index+1:].index('en')
>>> first_index
2
>>> second_index # 这里是因为从位置3开始到最后去寻找第二个‘en’，所以相当于新的列表是[3.14, 'haha', 88, 'en']
3
>>> s_index = first_index + second_index +1
>>> s_index
6
 
# 统计重复字符串个数
>>> list.count('en')
2
 
# extend添加列表
>>> s = ['come','go']
>>> list.extend(s)
>>> list
['a', 'b', 'en', 3.14, 'haha', 88, 'en', 'come', 'go']
 
#排序
 
list.sort()
 
#倒序
 
list.reverse()
 
# 拷贝
 
list2 = list.copy()
 
>>> list2
['a', 'b', 'en', 3.14, 'haha', 88, 'en', 'come', 'go']
 
# 看着内容相等，实际上占用了不同的内存
 
>>> id(list)
140199406210440
>>> id(list2)
140199406253256
 
# 排序
 
# 注意：无法对列表中多种类型进行排序，需统一格式
 
>>> list2[3] = '3.14'
 
>>> list2[5] = '88'
>>> list2
['a', 'b', 'en', '3.14', 'haha', '88', 'en', 'come', 'go']
 
# 正向排序
>>> list2.sort()
>>> list2
['3.14', '88', 'a', 'b', 'come', 'en', 'en', 'go', 'haha']
 
# 反向排序
>>> list2.reverse()
>>> list2
['haha', 'go', 'en', 'en', 'come', 'b', 'a', '88', '3.14']

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。

>>> t1 = ('a','b',3,99)
>>> t1
('a', 'b', 3, 99)
>>> t2 = ('haishiwo', 'youlaile')
>>> t2
('haishiwo', 'youlaile')
>>> t1[1]
'b'
>>> t1[-2]
3
>>> t1[1:3]
('b', 3)
>>> t2 * 2
('haishiwo', 'youlaile', 'haishiwo', 'youlaile')
>>> t1 + t2
('a', 'b', 3, 99, 'haishiwo', 'youlaile')

Set（集合）

集合（set）是一个无序不重复元素的序列。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号({})或者 set()函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

>>> list1 = ['a','b',3,'b',99,3]
>>> list1
['a', 'b', 3, 'b', 99, 3]
>>> set(list1)
{99, 3, 'b', 'a'}
>>> a = set('sdfsdfljljlj')
>>> b = set('fsck')
>>> a - b    # 差集
{'j', 'd', 'l'}
>>> a | b    # 并集
{'k', 'l', 's', 'j', 'd', 'f', 'c'}
>>> a & b    # 交集
{'s', 'f'}
>>> a ^ b    # 不同时存在
{'k', 'l', 'j', 'd', 'c'}

Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型

列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

>>> x = {}
>>> x['name'] = 'test'
>>> x
{'name': 'test'}
>>> x[2] = 56789
>>> x
{2: 56789, 'name': 'test'}
>>> x[2]
56789
>>> x.keys()
dict_keys([2, 'name'])
>>> x.values()
dict_values([56789, 'test'])
>>> x['name'] = 'huanmingzile'
>>> x
{2: 56789, 'name': 'huanmingzile'}
>>> {x: x**2 for x in (2,4,6)}
{2: 4, 4: 16, 6: 36}
>>> dict([('a',1),('b',2),('c',3)])
{'b': 2, 'a': 1, 'c': 3}
>>> dict(a=1,b=2,c=3)
{'b': 2, 'a': 1, 'c': 3}

# 创建字典
names = {
    'stu1101':'oldboy',
    'stu1201': {'name:':'hehe','hobbie':'girl'}
}
# 查询字典
print(names['stu1101'])
print(names['stu1201']['hobbie'])
# 修改字典，若不存在，会创建key和value
names['stu1301'] = 123
print(names,'\n','-'*10)
 
names['stu1201']['hobbie'] = 'python'
print(names,'\n','-'*10)
# 删除
print(names.pop('stu1301')) # 存在返回value
print(names.pop('stu1404','no such student found')) # 不存在返回后面的字符串
 
del names['stu1101']
print(names)
name = ['jack', 'rose', 'cai']
name1 = dict.fromkeys(name,[1,2,3])
print(name1)
name1['jack'][1] = 10
print(name1)
name1['jack'] = 100
print(name1)
# 打印
{'rose': [1, 2, 3], 'cai': [1, 2, 3], 'jack': [1, 2, 3]}
{'rose': [1, 10, 3], 'cai': [1, 10, 3], 'jack': [1, 10, 3]}
{'rose': [1, 10, 3], 'cai': [1, 10, 3], 'jack': 100}
# 这里就是想告诉你，改value中的某个值，是修改的内存指针中的这个value，所有的values都会跟着修改
# 如果修改了整个value，那就相当于重新开辟了一个内存，只会修改这一个value

Python算术运算符

以下假设变量a为10，变量b为21：

Python比较运算符

以下假设变量a为10，变量b为20：

Python赋值运算符

以下假设变量a为10，变量b为20：

Python位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13。

128 64 32 16 8 4 2 1
 
a = 22 # 0 0 0 1 0 1 1 0
b = 56 # 0 0 1 1 1 0 0 0
 
# & 按位与，都为真时为真，否则为假
a & b = 16     # 0 0 0 1 0 0 0 0
 
# | 按位或， 有一个为真时为真，否则为假
a | b = 63     # 0 0 1 1 1 1 1 0
 
# ^ 异或， 同为真或假时为假，不同为真
a ^ b =  46     # 0 0 1 0 1 1 1 0
 
# << 左移
a << 2 =  88    # 0 1 0 1 1 0 0 0
 
# >> 右移
b >> 2 =  14    # 0 0 0 0 1 1 1 0
 
# ~ 按位取反,第一位真取负数
~a = 1 1 1 0 1 0 0 1 = -128 + 64 + 32 + 8 + 1 = -23

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

Python身份运算符

身份运算符用于比较两个对象的存储单元

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：