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运算符优先级

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