python 数据类型为type python3 数据类型

转载

IT智行领袖 2023-06-07 15:28:08

文章标签 python 数据类型为type python 数据结构与算法 Python 字符串 文章分类 Python 后端开发

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 数据类型为type python3 数据类型_数据结构与算法

Python比较运算符

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

python 数据类型为type python3 数据类型_python_02

Python赋值运算符

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

python 数据类型为type python3 数据类型_Python_03

Python位运算符

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

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

python 数据类型为type python3 数据类型_字符串_04

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