Python-数据类型

主要数据类型

数字类型：int、long、float

字符串类型str

布尔bool

列表list、元组tuple

字典dict

集合set

字节bytes

查看数据类型

tpye(data)

数字类型

int（整型）

64位的机器上，整数的位数为64位。取值范围在，即 -9223372036854775808 ~ 923372036854775807

long（长整型）

理论上可以无限大，但是由于机器内存有限，所以也不可能无限大。

自从python3开始，就没有long了，全都是int型。

fload（浮点型）

浮点数即小数。

字符串Str

只要加了引号的字符都被认为是字符串。

字符串特性

• 不可修改
• 有索引，可切片

 不可修改是指，变量值不是在原有内存中修改。而是新建了内存空间，将变量名指向新的内存空间。

 有索引可切片，切片的区间是左闭右开。 

string[start:stop:step]。其中step步长可以为负数，当为负数时，可以实现反过来取值。（step的符号要和取值顺去对应，否则取值为空）

多行字符串

使用''' 三个单引号，赋值多行字符串

\n表示换行符

 字符串拼接

字符串内引用外部变量

• %s,%d,%f 占位符-格式化输出
• f

格式符号	转换
%%	输出%号
%s	字符串
%d	有符号的十进制整数
%f	浮点数，%.2f表示保留2位小数
%c	字符
%u	无符号的十进制整数
%o	八进制整数
%x	十六进制整数（小写字母0x）
%X	十六进制整数（大写字母0X）
%e	科学计数法(小写e)
%E	科学计数法（大写E）
%g	%f和%e的简写
%G	%f和%E的简写

 python3中可以使用 xxx = f"xxx{v_name}"的格式，引用变量

布尔类型

bool类型就两个值，一个true，一个false。主要作用是作为程序中的逻辑判断。

列表list

格式： list_name = ["value1","value2"...]

取值：list_name[index]

常用操作

增 list_name.append("xxx")

插入 list_name.insert(index,"xxx")

改 list_name[index] = "xxx"

查 name.index("xxx") 查询值所在的索引位置

查询list长度 len(list_name)

删 list_name.pop(index)；del list_name[index] ; list_name.remove("xxx")

切片

切片步长

 

 嵌套

排序和反转

import random

list1 = []
for i in range(8):
    list1.append(random.randint(1,20))
print(list1)
#排序sort
list1.sort()
print(list1)
#翻转sort的reverse参数 True降序，False或者没有升序
list1.sort(reverse=True)
print(list1)
#翻转reverse
list1.reverse()
print(list1)

元组tuple

特点：元组和列表是类似的，但是不同之处是，元组的元素是不能修改的（虽然不能修改元组，但是可以将两个元组通过+号进行连接）。元组使用小括号()表示。这里所说的修改，包括了增、删、改。

注意：如果元组里只有一个元素时，一定要以逗号结束，不然不是表示元组。元组同样支持下标和切片。

元组可以以逗号或小括号表示

t1 = 1,2,3
t2 = (1,2,3)
print(t1)
print(t2)

--------------
输出：
(1, 2, 3)
(1, 2, 3)

列表和元组，可以使用list()、tuple()转换格式

# 元组tuple
t1 = ()
print('t1', type(t1))
t2 = ('77',)
print('t2', type(t2))
t3 = ('xx', 'yy', 'zz')
l1 = list(t3)
print(l1)
t3 = tuple(l1)
print(t3)

-----------------
输出：
t1 <class 'tuple'>
t2 <class 'tuple'>
['xx', 'yy', 'zz']
('xx', 'yy', 'zz')

元组的拆包和装包

拆包

在python中，元组的拆包是自动的，不需要任何函数。拆包就是将元组中的元素，赋值给多个变量。一般情况下，接受赋值的变量个数要等于元组中的元素个数。

t1 = (1, 2, 3,)
a, b, c = t1
print(a, b, c)

--------------
输出：
1 2 3

当元素个数多余或少于接受赋值的变量个数时，python会给出明确的报错：

元素个数 > 接受赋值的变量：ValueError: too many values to unpack

元素个数 < 接受赋值的变量：ValueError: not enough values to unpack

如何在“变量个数 < 元素个数时接受赋值：

使用*arg 接收多个元组中的元素。

t1 = (1, 2, 3, 4, 5, 6, 7, 8)
a, *b, c = t1
print(a, b, c)


----------------
输出：
1 [2, 3, 4, 5, 6, 7] 8

同理*arg也可以用于“变量个数 > 元素个数”时接受赋值，此时*arg 会接受空列表

t2 = (90,)
a, *b = t2
print(a, b)

-----------
输出：
90 []

不光是元组可以拆包，字符串和列表也同样适用

s1 = 'xsdsadsadads'
a, *b, c = s1
print(a, b, c)

l1 = ['2', 'x', 'a', 'bv', 'll']
a, *b, c = l1
print(a, b, c)

---------------------
输出：
x ['s', 'd', 's', 'a', 'd', 's', 'a', 'd', 'a', 'd'] s
2 ['x', 'a', 'bv'] ll

容易绕晕的点：什么时候是拆包，什么时候是装包

t1 = (1, 2, 3, 4, 5, 6, 7, 8)
a, *b, c = t1      #拆包1
print(a, b, c)
print(*b)          #拆包2

---------
输出：
1 [2, 3, 4, 5, 6, 7] 8
2 3 4 5 6 7

拆包1：

a, *b, c = t1 ，此时元组t1被拆包，赋值给变量。

a = 1；c = 8； *b = 2，3，4，5，6，7。*b赋值时，为装包。

拆包2：print(*b)

所以：*arg。赋值时为装包，打印时是拆包。

字典-dictionary 

python中使用dictionary-字典，存储key-value。在其它语言中也称为map。

特点：

• 符号：{}
• 关键字：dict
• 保存的元素是key: value
• 字典中的键是不可以修改的，只可以修改值。键只可以删除
• 字典中的key的顺序不是根据添加的先后顺序排序的

必须符合固定格式的列表或元组，才可以转字典。

格式：list1 = [(key1,value1),(key2,value2)]   元组和字典都必须满足这样的格式。

dict1 = {}
print(type(dict1))

list1 = [("key1", "value1"), ("key2", "value2")]
dict2 = dict(list1)
print(dict2)

-----------------
输出：
<class 'dict'>
{'key1': 'value1', 'key2': 'value2'}

字典的增、删、改、查

添加&修改元素

格式：dict_name[key] = value

注意：key是唯一的，所以在添加的时候如果出现同名的key，则新的value会替换之前的value

dict1 = {}
dict1['name'] = 'liqi'
dict1['age'] = 27
print(dict1)
#修改元素
dict1['age'] = 18
print(dict1)

--------------
输出：
{'name': 'liqi', 'age': 27}
{'name': 'liqi', 'age': 18}

dict_name.setdefault('key','value')        #设置默认值，只可以添加的时候使用，无法修改。

dict_name1.update('dict_name2')        #实现两个字典的合并

删除

dict_name.clear            #清空

dict_name.pop('key')    #删除key

dict_name.popitem()    #删除最后一个键值对，返回值是键值对的元组

del dict_name['key'] or del dict_name    #删除key或者删除整个字典

dict1 = {'name': 'liqi', 'age': 27, 'hobby': 'basketball'}
print(dict1)
r = dict1.pop('age')
print(r, dict1)
dict1.clear()
print(dict1)

---------------
输出：
{'name': 'liqi', 'age': 27, 'hobby': 'basketball'}
27 {'name': 'liqi', 'hobby': 'basketball'}
{}

查询

对字典的查询，都是根据键去查询值。

dict_name.get('key',[默认值])

dict_name['key']        #如果key不存在会报错

dict1 = {'name': 'liqi', 'age': 27, 'hobby': 'basketball'}
value1 = dict1.get('name')
value2 = dict1['name']
print(value1, value2)
# get默认值
value3 = dict1.get('xxx', 'not found')
print(value3)

-------------
输出：
liqi liqi
not found

遍历

如果直接遍历字典，取出的是字典的key

dict1 = {'name': 'liqi', 'age': 27, 'hobby': 'basketball'}
for i in dict1:
    print(i)

--------------
输出：
name
age
hobby

如果要直接输出字典中的值，可以调用dict_name.values()

dict_name.keys()        #拿到所有的key

dict_name.values()     #拿到所有的value

dict_name.items()       #拿到键值对，格式：[('key1','value1'),('key2','value2'),('key3','value3')]

values = dict1.values()
print(values)
for v in dict1.values():
    print(v)

------------
输出：
dict_values(['liqi', 27, 'basketball'])
liqi
27
basketball

dict1 = {'name': 'liqi', 'age': 27, 'hobby': 'basketball'}
for k, v in dict1.items():  #拆包
    print(k, v)

-----
输出：
name liqi
age 27
hobby basketball

集合-set

关键字：set；符号：{}

特点：

• 没有重复，且无序
• 和字典相比，集合没有value。元素不是成对出现的

可以通过在{}内放入非成对的值定义集合，也可以将list列表转换成集合

对于申明空的set只能用 set1 = set()

set1 = {''}
set2 = {'1', '2', '3'}
set3 = set([1, 2, 3, 4])
print(type(set1))
print(type(set2))
print(type(set3))

-----------
输出：
<class 'set'>
<class 'set'>
<class 'set'>

将一个有重复值的列表转换成集合，可以看出来，集合中的值是没有重复的。

set_name.add(key)    #向集合中添加元素，虽然元素是最后添加的，但是没有排在最后。可以看出来集合是无序的。

set_name1.update(set_name2)    #将set_name2合并到set_name1中（set_name2本身不变）

set1 = set([1, 1, 1, 2, 2, 3, 3, 4, 8, 9])
print(set1)
set1.add(6)
print(set1)

set2 = {'x', 'a', 'w'}
set1.update(set2)
print(set1)
print(set2)

-------------
输出：
{1, 2, 3, 4, 8, 9}
{1, 2, 3, 4, 6, 8, 9}
{1, 2, 3, 4, 6, 8, 9, 'w', 'a', 'x'}
{'a', 'w', 'x'}

set_name.remove('key')    #删除集合中的key，如果key不存在会报错

set_name.discard('key')    #删除集合中的key，如果key不存在不会报错

set1 = set([1, 1, 1, 2, 2, 3, 3, 4, 8, 9])
print(set1)
set1.remove(9)
print(set1)

------
输出：
{1, 2, 3, 4, 8, 9}
{1, 2, 3, 4, 8}

set可以看作为数学意义上的无重复、无序的集合。因此，两个集合可以做数学意义上的交集和并集

set1 = set([1, 2, 3])
set2 = set([2, 3, 4])
set3 = set1 & set2    #交集
set4 = set1 | set2    #并集
print(set3)
print(set4)

-----------
输出：
{2, 3}
{1, 2, 3, 4}